diff --git a/.eslintrc b/.eslintrc index 2e74b787..19bdf662 100644 --- a/.eslintrc +++ b/.eslintrc @@ -40,7 +40,7 @@ "curly": [ "error" ], "dot-notation": [ "error" ], "eqeqeq": [ "error" ], - "id-length": [ "error" ], + "id-length": [ "error", { "exceptions": ["x", "y", "c"] } ], "indent": [ "error", 4, @@ -53,7 +53,7 @@ "error", "unix" ], - "new-cap": [ "error", { + "new-cap": [ "error", { "newIsCapExceptions": ["tClass"] }], "no-case-declarations": [ "error" ], diff --git a/.gitignore b/.gitignore index e8f5dc71..0777ec2a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,9 @@ **/node_modules/ *.log -.env \ No newline at end of file +.*env* +.idea +*__pycache__ +.DS_Store +*htmlcov +*.coverage +*.pytest_cache \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..ba831342 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,4 @@ +[submodule "lib/rpc_spec"] + path = lib/rpc_spec + url = https://github.com/smartdevicelink/rpc_spec.git + branch = master diff --git a/examples/js/hello-sdl/index.html b/examples/js/hello-sdl/index.html index 6ce9a4fd..9c007ab4 100644 --- a/examples/js/hello-sdl/index.html +++ b/examples/js/hello-sdl/index.html @@ -89,7 +89,7 @@ } async _onHmiStatusListener (onHmiStatus) { - const hmiLevel = onHmiStatus.getHMILevel(); + const hmiLevel = onHmiStatus.getHmiLevel(); // wait for the FULL state for more functionality if (hmiLevel === SDL.rpc.enums.HMILevel.HMI_FULL) { diff --git a/examples/node/hello-sdl/AppClient.js b/examples/node/hello-sdl/AppClient.js index 15a3818c..f19c0da8 100644 --- a/examples/node/hello-sdl/AppClient.js +++ b/examples/node/hello-sdl/AppClient.js @@ -92,7 +92,7 @@ class AppClient { } async _onHmiStatusListener (onHmiStatus) { - const hmiLevel = onHmiStatus.getHMILevel(); + const hmiLevel = onHmiStatus.getHmiLevel(); // wait for the FULL state for more functionality if (hmiLevel === SDL.rpc.enums.HMILevel.HMI_FULL) { diff --git a/generator/README.md b/generator/README.md new file mode 100644 index 00000000..84124498 --- /dev/null +++ b/generator/README.md @@ -0,0 +1,1741 @@ +# Proxy Library RPC Generator + +## Overview + +This script provides the possibility to auto-generate JavaScript code based on a given SDL MOBILE_API XML specification. + +## Requirements + +The script requires Python 3.5 pre-installed in the system. This is the minimal Python 3 version that has not reached the end-of-life (https://devguide.python.org/devcycle/#end-of-life-branches). + +Some required libraries are described in `requirements.txt` and should be pre-installed by the command: +```shell script +pip install -r requirements.txt +``` +Please also make sure before usage the 'lib/rpc_spec' Git submodule is successfully initialized, because the script uses the XML parser provided there. + +## Usage +```shell script +usage: generator.py [-h] [-v] [-xml SOURCE_XML] [-xsd SOURCE_XSD] + [-d OUTPUT_DIRECTORY] [-t [TEMPLATES_DIRECTORY]] + [-r REGEX_PATTERN] [--verbose] [-e] [-s] [-m] [-y] [-n] + +Proxy Library RPC Generator + +optional arguments: + -h, --help show this help message and exit + -v, --version print the version and exit + -xml SOURCE_XML, --source-xml SOURCE_XML, --input-file SOURCE_XML + should point to MOBILE_API.xml + -xsd SOURCE_XSD, --source-xsd SOURCE_XSD + -d OUTPUT_DIRECTORY, --output-directory OUTPUT_DIRECTORY + define the place where the generated output should be + placed + -t [TEMPLATES_DIRECTORY], --templates-directory [TEMPLATES_DIRECTORY] + path to directory with templates + -r REGEX_PATTERN, --regex-pattern REGEX_PATTERN + only elements matched with defined regex pattern will + be parsed and generated + --verbose display additional details like logs etc + -e, --enums only specified elements will be generated, if present + -s, --structs only specified elements will be generated, if present + -m, -f, --functions only specified elements will be generated, if present + -y, --overwrite force overwriting of existing files in output + directory, ignore confirmation message + -n, --skip skip overwriting of existing files in output + directory, ignore confirmation message +``` + +# JavaScript ES6 Transformation rules + +## Overview +These are the general transformation rules for RPC classes of SDL JavaScript Suite Library. The description of base classes, already included in the library, is not provided here, for details please view the source code. + +The JSDoc is used for inline documentation of generated code. All non-XML values should follow Architecture & Contribution Guidelines (GUIDELINES.md) + +These rules based on the current `develop` branch state (commit:`c5b3b448e008dadc9a5b66addde17633ac957700`) of [`smartdevicelink/sdl_javascript_suite`](https://github.com/smartdevicelink/sdl_javascript_suite) repository. + +## The License Header +All files should start from the comment with the license information. + +```javascript +/* +* Copyright (c) [year], SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ +``` +Where `[year]` in the copyright line is the current year. + +## `` +Each Enum class should be stored as a single script file in the folder named `enums` and the name of the script file should be equal to the value from the `"name"` attribute of `` followed by the extension `.js`. + +Example: +```shell script +enums/ImageType.js +``` +The script should import the base Enum class and the produced class should extend it. The name of the class is the value from the `"name"` attribute of ``. The constructor has no params and should call `super()`. + +The class should have the next JSDoc comment: +```javascript +/** + * [description] + * @typedef {Enum} [enum_name] + * @property {Object} _MAP + */ +``` +Where `[description]` is `` of the current ``, if exists, and `[enum_name]` is the value of the `"name"` attribute. + +The constructor should have the next JSDoc comment: +```javascript +/** + * @constructor + */ +``` + +Example: +```javascript +import { Enum } from '_path_to_base_classes_/Enum.js'; + +/** + * Contains information about the type of image. + * @typedef {Enum} ImageType + * @property {Object} _MAP + */ +class ImageType extends Enum { + + /** + * @constructor + */ + constructor() { + super(); + } +} +``` +The set of `` should be mapped to the frozen object and put into the private static property `_MAP`. + +The following list are general rules for keys and values of this object: + +1. The `"name"` attribute is the base value for both the key and the value of the mapped object. +2. In case if the `"internal_name"` attribute exists, this should be used for the key instead of the `"name"` attribute. +3. In case if the `"value"` attribute exists, this attribute should be used for the value instead of the `"name"` attribute. +4. In case if the `"hexvalue"` attribute exists, this attribute should be used for the value instead of the `"value"` and `"name"` attributes. +5. Uses of the "sync" prefix shall be replaced with "sdl" (where it would not break functionality). E.g. `SyncMsgVersion -> SdlMsgVersion`. This applies to member variables and their accessors. The key used when creating the RPC message JSON should match that of the RPC Spec. +6. The `_MAP` keys and static getters of the `FunctionID` enum shall not include the ID suffix. e.g. `RegisterAppInterfaceID -> RegisterAppInterface`. + +According to ES6 standard, static (class-side) data properties and prototype data properties must be defined outside of the ClassBody declaration. + +Example: +```javascript +ImageType._MAP = Object.freeze({ + 'STATIC': 'STATIC', + 'DYNAMIC': 'DYNAMIC', +}); +``` + +For each `` the static getter method should be defined in the class. The name of the getter is the `"internal_name"` or `"name"` attribute value, the same as `_MAP` keys. The returned value is the value from the frozen object described above taken by the corresponding key. + +The getter should have the next JSDoc comment: +```javascript +/** + * [description] + * @return {[enum_type]} + */ +``` +Where `[description]` is `` of the current ``, if exists, and `[enum_type]` is the one of `String` or `Number`. + +Example: +```javascript +/** + * @return {String} + */ +static get STATIC() { + return ImageType._MAP.STATIC; +} + +/** + * @return {String} + */ +static get DYNAMIC() { + return ImageType._MAP.DYNAMIC; +} +``` +The base Enum class requires subclasses to override and implement the `valueForKey` method with one parameter named `"key"`. This implementation should return a given enumeration **`value`** if the provided **`key`** exists in the collection (otherwise `null`) using the _valueForKey(key) private method found in the base Enum class. + +This method should have the next JSDoc comment: +```javascript +/** + * A method for subclasses to implement that does what _keyForValue does + * @param key - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ +``` + +Example: +```javascript +/** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ +static valueForKey (key) { + return ImageType._valueForKey(key, ImageType._MAP); +} +``` +Also the base Enum class requires subclasses to override and implement the `keyForValue` method with one parameter named `"value"`. This implementation should return a given enumeration **`key`** if the provided **`value`** exists in the collection (otherwise `null`) using the __keyForValue(value) private method found in the base Enum class. + +This method should have the next JSDoc comment: +```javascript +/** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ +``` + +Example: +```javascript +/** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ +static keyForValue (value) { + return ImageType._keyForValue(value, ImageType._MAP); +} +``` +After the `_MAP` definition, the script should export the produced class. + +Example: +```javascript +export { ImageType }; +``` + +### Below are examples of `` with different `` attributes + + +#### Example with only `"name"` attribute: + +XML: +```xml + + Contains information about the type of image. + + + +``` + +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '_path_to_base_classes_/Enum.js'; + +/** + * Contains information about the type of image. + * @typedef {Enum} ImageType + * @property {Object} _MAP + */ +class ImageType extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get STATIC () { + return ImageType._MAP.STATIC; + } + + /** + * @return {String} + */ + static get DYNAMIC () { + return ImageType._MAP.DYNAMIC; + } + + /** + * Get the value for the given enum key + * @param value - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return ImageType._valueForKey(key, ImageType._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return ImageType._keyForValue(value, ImageType._MAP); + } +} + +ImageType._MAP = Object.freeze({ + 'STATIC': 'STATIC', + 'DYNAMIC': 'DYNAMIC', +}); + +export { ImageType }; +``` + +#### Example with `"internal_name"` and `"name"` attribute: + +XML: +```xml + + Contains information about the VR capabilities. + + +``` + +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '_path_to_base_classes_/Enum.js'; + +/** + * Contains information about the VR capabilities. + * @typedef {Enum} VrCapabilities + * @property {Object} _MAP + */ +class VrCapabilities extends Enum { + constructor () { + super(); + } + + /** + * @return {String} + */ + static get VR_TEXT () { + return VrCapabilities._MAP.VR_TEXT; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VrCapabilities._valueForKey(key, VrCapabilities._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VrCapabilities._keyForValue(value, VrCapabilities._MAP); + } +} + +VrCapabilities._MAP = Object.freeze({ + 'VR_TEXT': 'TEXT', +}); + +export { VrCapabilities }; +``` + +#### Example with `"value"` attribute: + +XML: +```xml + + + The default window is a main window pre-created on behalf of the app. + + + The primary widget of the app. + + +``` + +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ +import { Enum } from '_path_to_base_classes_/Enum.js'; + +/** + * @typedef {Enum} PredefinedWindows + * @property {Object} _MAP + */ +class PredefinedWindows extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * The primary widget of the app. + * @return {Number} + */ + static get PRIMARY_WIDGET () { + return PredefinedWindows._MAP.PRIMARY_WIDGET; + } + + /** + * The default window is a main window pre-created on behalf of the app. + * @return {Number} + */ + static get DEFAULT_WINDOW () { + return PredefinedWindows._MAP.DEFAULT_WINDOW; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return PredefinedWindows._valueForKey(key, PredefinedWindows._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return PredefinedWindows._keyForValue(value, PredefinedWindows._MAP); + } +} + +PredefinedWindows._MAP = Object.freeze({ + 'PRIMARY_WIDGET': 1, + 'DEFAULT_WINDOW': 0, +}); + +export { PredefinedWindows }; +``` + +#### Example with `"hexvalue"` attribute: + +XML: +```xml + + Enumeration linking function names with function IDs in SmartDeviceLink protocol. Assumes enumeration starts at value 0. + + + + +``` + +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ +import { Enum } from '_path_to_base_classes_/Enum.js'; + +/** + * Enumeration linking function names with function IDs in SmartDeviceLink protocol. Assumes enumeration starts at value 0. + * @typedef {Enum} FunctionID + * @property {Object} _MAP + */ +class FunctionID extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {Number} + */ + static get RESERVED () { + return FunctionID._MAP.RESERVED; + } + + /** + * @return {Number} + */ + static get RegisterAppInterface () { + return FunctionID._MAP.RegisterAppInterface; + } + + /** + * @return {Number} + */ + static get Slider () { + return FunctionID._MAP.Slider; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return FunctionID._valueForKey(key, FunctionID._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return FunctionID._keyForValue(value, FunctionID._MAP); + } +} + +FunctionID._MAP = Object.freeze({ + 'RESERVED': 0x0, + 'RegisterAppInterface': 0x1, + 'Slider': 0x1A, +}); + +export { FunctionID }; +``` + +## `` +Each Struct class should be stored as a single script file in the folder named `structs` and the name of the script file should be equal to the value from the `"name"` attribute of `` following by the extension `.js`. + +Example: +```shell script +structs/VehicleDataResult.js +``` + +The script should import the base `RpcStruct` class and the produced class should extend it. The name of the class is the value from the `"name"` attribute of ``. + +The script should also import any Enum and Struct classes, that are used in the represented structure. + +The constructor has one parameter named `parameters` to pass the JavaScript object with initial values of the represented structure and should call `super(parameters)` to pass this object into the base class. + +The class should have the next JSDoc comment: +```javascript +/** + * [description] + */ +``` +Where `[description]` is `` of the current ``, if exists. + +The constructor should have the next JSDoc comment: +```javascript +/** + * @constructor + */ +``` + +Example: +```javascript +import { RpcStruct } from '_path_to_base_classes_/RpcStruct.js'; +import { VehicleDataType } from '../enums/VehicleDataType.js'; +import { VehicleDataResultCode } from '../enums/VehicleDataResultCode.js'; + +/** + * Individual published data request result + */ +class VehicleDataResult extends RpcStruct { + + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } +} +``` + +The set of `` should be mapped to the static properties of the new class by following rules: + +1. The name of the property is the `SCREAMING_SNAKE_CASE` formatted value of the `"name"` attribute of `` with the `KEY_` prefix. +2. The value of the property is the value of the `"name"` attribute of `` +3. Uses of the "sync" prefix shall be replaced with "sdl" (where it would not break functionality). E.g. `KEY_SYNC_MSG_VERSION -> KEY_SDL_MSG_VERSION`. This applies to member variables and their accessors. The key used when creating the RPC message JSON should match that of the RPC Spec. + +According to ES6 standard, static (class-side) data properties and prototype data properties must be defined outside of the ClassBody declaration. + +Example: +```javascript +VehicleDataResult.KEY_DATA_TYPE = 'dataType'; +VehicleDataResult.KEY_RESULT_CODE = 'resultCode'; +VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE = 'oemCustomDataType'; +``` + +For each `` the getter and setter methods should be defined in the class: + +1. The name of the getter is the `PascalCase` formatted value of the `"name"` attribute with the `get` prefix, for the setter the prefix should be `set`. +2. Uses of the "sync" prefix shall be replaced with "sdl" (where it would not break functionality). E.g. `SyncMsgVersion -> SdlMsgVersion`. This applies to member variables and their accessors. The key used when creating the RPC message JSON should match that of the RPC Spec. +3. If the `` has the `"type"` attribute value as one of `Boolean`, `Float`, `Integer`, `String`: + * The getter should call and return the result of the `this.getParameter` method, where the single parameter is the value of the corresponding static property described above; + * The setter should call the `this.setParameter` method, where the first parameter is the value of the corresponding static property described above, the second is the value passed into setter; + * The setter should return `this` instance to support the chaining. +4. If the `` has the `"type"` attribute value as the one of `` or `` name: + * The getter should call and return the result of the `this.getObject` method, where the first parameter is the corresponding Struct or Enum class, the second is the value of the corresponding static property described above; + * The setter should validate the received value by calling the `this.validateType` method, where the fist parameter is the Struct or Enum class corresponding to the `"type"` attribute value of ``, the second is the value itself; + * The setter should call the `this.setParameter` method, where the first parameter is the value of the corresponding static property described above, the second is the value passed into setter; + * The setter should return `this` instance to support the chaining. + +The setter should have the next JSDoc comment: +```javascript +/** + * @param {[param_type]} [value_name] [description] + * @return {[struct_name]} + */ +``` +Where `[param_type]` is the `"type"` attribute, `[value_name]` is the lowercase last part of the `"name"` attribute, `[description]` is `` of the current ``, if exists, and `[struct_name]` is the `"name"` attribute of the current Struct. + +The getter should have the next JSDoc comment: +```javascript +/** + * @return {[param_type]} + */ +``` +Where `[param_type]` is the `"type"` attribute of the current ``. + + +Examples: +```javascript +/** + * @param {VehicleDataType} type Defined published data element type. + * @return {VehicleDataResult} + */ +setDataType(type) { + this.validateType(VehicleDataType, type); + this.setParameter(VehicleDataResult.KEY_DATA_TYPE, type); + return this; +} + +/** + * @return {VehicleDataType} + */ +getDataType() { + return this.getObject(VehicleDataType, VehicleDataResult.KEY_DATA_TYPE); +} + +/** + * @param {String} type Type of requested oem specific parameter + * @return {VehicleDataResult} + */ +setOemCustomDataType(type) { + this.setParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE, type); + return this; +} + +/** + * @return {String} + */ +getOemCustomDataType() { + return this.getParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE); +} +``` + +After the static properties definition, the script should export the produced class. + +Example: +```javascript +export { VehicleDataResult }; +``` + +### Below is the full example of the Struct class with simple and Enum parameters inside: + +XML: +```xml + + Individual published data request result + + Defined published data element type. + + + Published data result code. + + + Type of requested oem specific parameter + + +``` + +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '_path_to_base_classes_/RpcStruct.js'; +import { VehicleDataType } from '../enums/VehicleDataType.js'; +import { VehicleDataResultCode } from '../enums/VehicleDataResultCode.js'; + +/** + * Individual published data request result + */ +class VehicleDataResult extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {VehicleDataType} type - Defined published data element type. + * @return {VehicleDataResult} + */ + setDataType (type) { + this.validateType(VehicleDataType, type); + this.setParameter(VehicleDataResult.KEY_DATA_TYPE, type); + return this; + } + + /** + * @return {VehicleDataType} + */ + getDataType () { + return this.getObject(VehicleDataType, VehicleDataResult.KEY_DATA_TYPE); + } + + /** + * @param {VehicleDataResultCode} code - Published data result code. + * @return {VehicleDataResult} + */ + setResultCode (code) { + this.validateType(VehicleDataResultCode, code); + this.setParameter(VehicleDataResult.KEY_RESULT_CODE, code); + return this; + } + + /** + * @return {VehicleDataResultCode} + */ + getResultCode () { + return this.getObject(VehicleDataResultCode, VehicleDataResult.KEY_RESULT_CODE); + } + + /** + * @param {String} type - Type of requested oem specific parameter + * @return {VehicleDataResult} + */ + setOemCustomDataType (type) { + this.setParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getOemCustomDataType () { + return this.getParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE); + } +} + +VehicleDataResult.KEY_DATA_TYPE = 'dataType'; +VehicleDataResult.KEY_RESULT_CODE = 'resultCode'; +VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE = 'oemCustomDataType'; + +export { VehicleDataResult }; +``` + +## `` + +Each Function class should be stored as a single script file in the folder named `messages` and the name of the script is the value from the `"name"` attribute of `` (followed by additional suffix `Response` if the `"messagetype"` attribute is set to `response`) followed by the extension `.js`. + +Example: +```shell script +messages/AddCommand.js +messages/AddCommandResponse.js +messages/OnLanguageChange.js +``` + +There are some prerequisites for the Function class: + +1. Based on the value of the `"messagetype"` attribute of ``, the script should import the base class `RpcRequest`, `RpcResponse` or `RpcNotification` class and the produced class should extend the imported base class. +2. The script should import `enums/FunctionID.js` to get the `functionID` hex value of the current RPC function. The key of the required `` of `FunctionID` enum is the value of the `"functionID"` attribute of ``. +3. The script should import all Enum and Struct classes, that are used by the representing function. +4. The name of the class is the value from the `"name"` attribute of `` (followed by additional suffix `Response` if the `"messagetype"` attribute is set to `response`), e.g. `AddCommand`, `AddCommandResponse`, `OnLanguageChange`. +5. The constructor has one parameter named `store` to pass the JavaScript object with initial values of the function params and should call `super(store)` to pass this object into the parent class. +6. The constructor should call `this.setFunctionName` method with the correspond `FunctionID` value described in the point 2, e.g. `FunctionID.AddCommandID`. + +The class should have the next JSDoc comment: +```javascript +/** + * [description] + */ +``` +Where `[description]` is `` of the current ``, if exists. + +The constructor should have the next JSDoc comment: +```javascript +/** + * @constructor + */ +``` + +Example: +```javascript +import { RpcRequest } from '_path_to_base_classes_/RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { Image } from '../enums/Image.js'; +import { MenuParams } from '../enums/MenuParams.js'; + +/** + * Adds a command to the in application menu. Either menuParams or vrCommands must be provided. + */ +class AddCommand extends RpcRequest { + + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.AddCommandID); + } +} +``` + +Example: +```javascript +import { RpcResponse } from '_path_to_base_classes_/RpcResponse.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +class AddCommandResponse extends RpcResponse { + + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.AddCommandID); + } +} +``` + +Example: +```javascript +import { RpcNotification } from '_path_to_base_classes_/RpcNotification.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { Language } from '../enums/Language.js'; +import { MenuParams } from '../enums/MenuParams.js'; + +class OnLanguageChange extends RpcNotification { + + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnLanguageChangeID); + } +} +``` + +The set of `` should be mapped to the static properties of the new class by following rules: + +1. The name of the property is the `SCREAMING_SNAKE_CASE` formatted value of the `"name"` attribute of `` with the `KEY_` prefix. +2. Uses of the "sync" prefix shall be replaced with "sdl" (where it would not break functionality). E.g. `SyncMsgVersion -> SdlMsgVersion`. This applies to member variables and their accessors. The key used when creating the RPC message JSON should match that of the RPC Spec. +3. The value of the property is the value of the "name" attribute of +4. The exclusion are `` with name `success`, `resultCode` and `info` of `` with the attribute `messagetype="response"`, in this case they should be omitted. + +According to ES6 standard, static (class-side) data properties and prototype data properties must be defined outside of the ClassBody declaration. + +Example: +```javascript +AddCommand.KEY_CMD_ID = 'cmdID'; +OnLanguageChange. KEY_LANGUAGE = 'language'; +OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; +``` + +For each `` the getter and setter methods should be defined in the class: + +1. The name of the getter is the `PascalCase` formatted value of the `"name"` attribute with the `get` prefix, for the setter the prefix should be `set`. +2. If the `` has the `"type"` attribute value as one of `Boolean`, `Float`, `Integer`, `String`: + * The getter should call and return the result of the `this.getParameter` method, where the single parameter is the value of the corresponding static property described above; + * The setter should call the `this.setParameter` method, where the first parameter is the value of the corresponding static property described above, the second is the value passed into setter; + * The setter should return `this` instance to support the chaining. +3. If the `` has the `"type"` attribute value as the one of `` or `` name: + * The getter should call and return the result of the `this.getObject` method, where the first parameter is the corresponding Struct or Enum class, the second is the value of the corresponding static property described above; + * The setter should validate the received value by calling the `this.validateType` method, where the fist parameter is the Struct or Enum class corresponding to the `"type"` attribute value of ``, the second is the value itself; + * The setter should call the `this.setParameter` method, where the first parameter is the value of the corresponding static property described above, the second is the value passed into setter; + * The setter should return `this` instance to support the chaining. +4. The exclusion are `` with name `success`, `resultCode` and `info` of `` with the attribute `messagetype="response"`, in this case they should be omitted. + +The setter should have the next JSDoc comment: +```javascript +/** + * @param {[param_type]} [value_name] [description] + * @return {[struct_name]} + */ +``` +Where `[param_type]` is the `"type"` attribute, `[value_name]` is the lowercase last part of the `"name"` attribute, `[description]` is `` of the current ``, if exists, and `[struct_name]` is the `"name"` attribute of the current Struct. + +The getter should have the next JSDoc comment: +```javascript +/** + * @return {[param_type]} + */ +``` +Where `[param_type]` is the `"type"` attribute of the current ``. + +Example: +```javascript +/** + * @param {Number} cmdid unique ID of the command to add. + * @return {AddCommand} + */ +setCmdID(id) { + this.setParameter(AddCommand.KEY_CMD_ID, id); + return this; +} + +/** + * @return {Number} + */ +getCmdID() { + return this.getParameter(AddCommand.KEY_CMD_ID); +} + +/** + * @param {MenuParams} params Optional sub value containing menu parameters + * @return {AddCommand} + */ +setMenuParams(menuParams) { + this.validateType(MenuParams, menuParams); + this.setParameter(AddCommand.KEY_MENU_PARAMS, menuParams); + return this; +} + +/** + * @return {MenuParams} + */ +getMenuParams() { + return this.getObject(MenuParams, AddCommand.KEY_MENU_PARAMS); +} + +/** + * @param {Language} language Current display language + * @return {OnLanguageChange} + */ +setHmiDisplayLanguage(language) { + this.validateType(Language, language); + this.setParameter(OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE, language); + return this; +} + +/** + * @return {Language} + */ +getHmiDisplayLanguage() { + return this.getObject(Language, OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE); +} +``` + +After the static properties definition, the script should export the produced class. + +Example: +```javascript +export { AddCommand }; +``` + +### Below are full examples for Request, Response and Notification. +#### Request Example: + +XML: +```xml + + + Adds a command to the in application menu. + Either menuParams or vrCommands must be provided. + + + + unique ID of the command to add. + + + + Optional sub value containing menu parameters + + + + + An array of strings to be used as VR synonyms for this command. + If this array is provided, it may not be empty. + + + + + + Image struct determining whether static or dynamic icon. + If omitted on supported displays, no (or the default if applicable) icon shall be displayed. + + + + +``` + +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '_path_to_base_classes_/RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { Image } from '../structs/Image.js'; +import { MenuParams } from '../structs/MenuParams.js'; + +/** + * Adds a command to the in application menu. Either menuParams or vrCommands must be provided. + */ +class AddCommand extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.AddCommand); + } + + /** + * @param {Number} id - unique ID of the command to add. + * @return {AddCommand} + */ + setCmdID (id) { + this.setParameter(AddCommand.KEY_CMD_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCmdID () { + return this.getParameter(AddCommand.KEY_CMD_ID); + } + + /** + * @param {MenuParams} params - Optional sub value containing menu parameters + * @return {AddCommand} + */ + setMenuParams (params) { + this.validateType(MenuParams, params); + this.setParameter(AddCommand.KEY_MENU_PARAMS, params); + return this; + } + + /** + * @return {MenuParams} + */ + getMenuParams () { + return this.getObject(MenuParams, AddCommand.KEY_MENU_PARAMS); + } + + /** + * @param {Array} commands - An array of strings to be used as VR synonyms for this command. If this array + * is provided, it may not be empty. + * @return {AddCommand} + */ + setVrCommands (commands) { + this.setParameter(AddCommand.KEY_VR_COMMANDS, commands); + return this; + } + + /** + * @return {Array} + */ + getVrCommands () { + return this.getParameter(AddCommand.KEY_VR_COMMANDS); + } + + /** + * @param {Image} icon - Image struct determining whether static or dynamic icon. If omitted on supported displays, + * no (or the default if applicable) icon shall be displayed. + * @return {AddCommand} + */ + setCmdIcon (icon) { + this.validateType(Image, icon); + this.setParameter(AddCommand.KEY_CMD_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getCmdIcon () { + return this.getObject(Image, AddCommand.KEY_CMD_ICON); + } +} + +AddCommand.KEY_CMD_ID = 'cmdID'; +AddCommand.KEY_MENU_PARAMS = 'menuParams'; +AddCommand.KEY_VR_COMMANDS = 'vrCommands'; +AddCommand.KEY_CMD_ICON = 'cmdIcon'; + +export { AddCommand }; +``` + +#### Response Example: + +> Please pay attention that no other parameters for this example except "info", "success" and "resultCode", thus they were omitted and only the constructor and other parameters are present) + +XML: +```xml + + + true if successful; false, if failed + + + + See Result + + + + + + + + + + + + + + + + + Provides additional human readable info regarding the result. + + + + + ID of the choice that was selected in response to PerformInteraction. + Only is valid if general result is "success:true". + + + + + + Manually entered text selection, e.g. through keyboard + Can be returned in lieu of choiceID, depending on trigger source + + + + + + See TriggerSource + Only is valid if resultCode is SUCCESS. + + + + +``` + +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcResponse } from '_path_to_base_classes_/RpcResponse.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { TriggerSource } from '../enums/TriggerSource.js'; + +class PerformInteractionResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PerformInteraction); + } + + /** + * @param {Number} id - ID of the choice that was selected in response to PerformInteraction. Only is valid if + * general result is "success:true". + * @return {PerformInteractionResponse} + */ + setChoiceID (id) { + this.setParameter(PerformInteractionResponse.KEY_CHOICE_ID, id); + return this; + } + + /** + * @return {Number} + */ + getChoiceID () { + return this.getParameter(PerformInteractionResponse.KEY_CHOICE_ID); + } + + /** + * @param {String} entry - Manually entered text selection, e.g. through keyboard Can be returned in lieu of + * choiceID, depending on trigger source + * @return {PerformInteractionResponse} + */ + setManualTextEntry (entry) { + this.setParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY, entry); + return this; + } + + /** + * @return {String} + */ + getManualTextEntry () { + return this.getParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY); + } + + /** + * @param {TriggerSource} source - See TriggerSource Only is valid if resultCode is SUCCESS. + * @return {PerformInteractionResponse} + */ + setTriggerSource (source) { + this.validateType(TriggerSource, source); + this.setParameter(PerformInteractionResponse.KEY_TRIGGER_SOURCE, source); + return this; + } + + /** + * @return {TriggerSource} + */ + getTriggerSource () { + return this.getObject(TriggerSource, PerformInteractionResponse.KEY_TRIGGER_SOURCE); + } +} + +PerformInteractionResponse.KEY_CHOICE_ID = 'choiceID'; +PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY = 'manualTextEntry'; +PerformInteractionResponse.KEY_TRIGGER_SOURCE = 'triggerSource'; + +export { PerformInteractionResponse }; +``` +#### Notification Example: +XML: +```xml + + + Current SDL voice engine (VR+TTS) language + + + Current display language + + +``` +The Output: +```javascript +/* +* Copyright (c) 2019, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcNotification } from '_path_to_base_classes_/RpcNotification.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { Language } from '../enums/Language.js'; + +class OnLanguageChange extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnLanguageChange); + } + + /** + * @param {Language} language - Current SDL voice engine (VR+TTS) language + * @return {OnLanguageChange} + */ + setLanguage (language) { + this.validateType(Language, language); + this.setParameter(OnLanguageChange.KEY_LANGUAGE, language); + return this; + } + + /** + * @return {Language} + */ + getLanguage () { + return this.getObject(Language, OnLanguageChange.KEY_LANGUAGE); + } + + /** + * @param {Language} language - Current display language + * @return {OnLanguageChange} + */ + setHmiDisplayLanguage (language) { + this.validateType(Language, language); + this.setParameter(OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE, language); + return this; + } + + /** + * @return {Language} + */ + getHmiDisplayLanguage () { + return this.getObject(Language, OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE); + } +} + +OnLanguageChange.KEY_LANGUAGE = 'language'; +OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; + +export { OnLanguageChange }; +``` + +# Custom mapping + +## Overview + +There are cases named `edge cases` when it is not possible to get the required info from XML or some manual additions are required in generated classes. For that purpose the generator includes the custom mapping file `mapping.json` that allows to add required customizations. + +## Structure + +The customization script contains the JSON object. Below is the schema: + +```json +{ + ["enums"|"structs"|"functions"]: { + [enum_name|struct_name|function_name]: { + [element_name|param_name]: { + "-methods": {}, + "methods": { + "method_title": [custom_method_title], + "key": [custom_key_name], + "description": [custom_description] + }, + "params": { + "key": [custom_key_name] + "value": [custom_value] + }, + }, + "params": [ + { + "key": [custom_param_name], + "value": [custom_param_value] + } + ], + "script": [path_to_custom_code] + } + } +} +``` + +Root keys in the structure are `"enums"`, `"structs"` and `"functions"`. The key on the next level is the corresponding name of required ``, `` or ``. On the next level, the name of `` or `` is expected. Also, at this level, it is possible to add any custom code into class from the file via the `script` key and to add custom params to class properties via an array from `params` key. See the detailed description below. + +The mapping object does not provide the possibility to create brand new ``, `` or ``, and their child elements in this way. The customization is allowed only for existing XML elements, unexisting names of elements and their child elements defined int the mapping object will be ignored. + +## Adding the custom code +As described above the custom code could be added via `script` key. The value of this key should be the path to the file. The code will be included as-is directly into the class, therefore only comments and method definitions are allowed in this file. + +Example: +```json +{ + "functions": { + "PutFileRequest": { + "script": "templates/scripts/PutFileRequest.js" + } + } +} +``` + +The content of the `templates/scripts/PutFileRequest.js` file is: +```javascript +// ------ Not part of the RPC spec itself ----- + +/** + * @param {Uint8Array} fileData + * @return {PutFile} + */ +setFileData(fileData) { + this.setBulkData(fileData); + return this; +} +/** + * @return {Uint8Array} + */ +getFileData() { + return this.getBulkData(); +} + +//----------------- END ----------------------- +``` +This code will be included into `PutFileRequest` class of the `messages/PutFileRequest.js` file as-is. + +## Adding custom parameters +As described above the custom code could be added via `params` key. The value of this key should be the array of objects. Each that object should include `key` and `value` properties for defining the name and the value of the new parameter. + +Following example demonstrates the object and the code that will be generated for Enums and Structs/Functions: +```json +{ + "key": "APP_ID_MAX_LENGTH", + "value": 10 +} +``` + +In Enums this will produce the new property in the static `_MAP` object +```javascript +_EnumClass_._MAP = Object.freeze({ + // ..., + 'APP_ID_MAX_LENGTH': 10, + // ... +}); +``` + +In Structs/Functions this will produce the new static property +```javascript +// ... +_StructClass_.APP_ID_MAX_LENGTH = 10; +// ... +``` +```javascript +// ... +_FunctionClass_.APP_ID_MAX_LENGTH = 10; +// ... +``` + +## Customization the `` of `` or the `` of ``/`` +In order of this customization it is possible to change the name and description of getter/setter methods and the name and value of corresponding static property. Additionally it is possible to remove getter/setter methods. + +### Changing the name and description of getter/setter methods +To change the name and description of getter/setter methods it needs to define `methods.method_title` value. + +Example: +```json +{ + "enums": { + "AudioType": { + "PCM": { + "methods": { + "method_title": "Wave", + "description": "Linear Wave!" + } + } + } + } +} +``` + +This will replace the `PCM` method name to `Wave` and `Linear PCM.` description to `Linear Wave!`, please pay attention the `_MAP` still has the `PCM` key. +```javascript + /* + * Linear Wave! + * @return {String} + */ + static get Wave () { + return AudioType._MAP.PCM; + } +``` + +### Changing the name and value of corresponding static property +To change the name of corresponding static property it needs to define `params.key` value. + +To change the value of corresponding static property it needs to define `params.value` value. + +Example: +```json +{ + "enums": { + "AudioType": { + "PCM": { + "methods": { + "key": "Wave" + }, + "params": { + "key": "Wave", + "value": "NEW_PCM" + } + } + } + } +} +``` + +The result will the following. Please pay attention that in case if the name of the static property was changed, you should also define the same `methods.key` value, otherwise the key will be unchanged in getter/setter methods. +```javascript + +class AudioType extends Enum { +// ... + /* + * Linear PCM. + * @return {String} + */ + static get PCM () { + return AudioType._MAP.Wave; // will be old `AudioType._MAP.PCM` if `methods.key` is not defined + } +// ... +} + +AudioType._MAP = Object.freeze({ + // ..., + 'Wave': "NEW_PCM", // old key/value PCM: "PCM" + // ... +}); +``` + +### Removing getter/setter methods +To remove getter/setter methods it needs to define `-methods` key, the value of this key doesn't matter. + +Example: +```json +{ + "enums": { + "AudioType": { + "PCM": { + "-methods": {} + } + } + } +} +``` + +This will remove `static get PCM` method from the class and only the `_MAP` key/value will be generated. diff --git a/generator/__init__.py b/generator/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/generator/generator.py b/generator/generator.py new file mode 100644 index 00000000..9d79e27e --- /dev/null +++ b/generator/generator.py @@ -0,0 +1,455 @@ +"""This is main runner of generator + +""" + +import logging +import re +import sys +from argparse import ArgumentParser +from collections import namedtuple +from datetime import date +from inspect import getfile +from itertools import groupby +from json import JSONDecodeError, loads +from os.path import basename +from pprint import pformat +from time import sleep + +from jinja2 import Environment, FileSystemLoader, TemplateNotFound, UndefinedError +from pathlib2 import Path + +ROOT = Path(__file__).absolute().parents[0] + +sys.path.append(ROOT.parents[0].joinpath('lib/rpc_spec/InterfaceParser').as_posix()) + +try: + from parsers.sdl_rpc_v2 import Parser + from parsers.rpc_base import ParseError + from model.interface import Interface + from transformers.generate_error import GenerateError + from transformers.common_producer import InterfaceProducerCommon + from transformers.enums_producer import EnumsProducer + from transformers.functions_producer import FunctionsProducer + from transformers.structs_producer import StructsProducer +except ModuleNotFoundError as message: + print('%s.\nprobably you did not initialize submodule', message) + sys.exit(1) + + +class Generator: + """ + This class contains only technical features, as follow: + - parsing command-line arguments, or evaluating required Paths interactively; + - calling parsers to get Model from xml; + - calling producers to transform initial Model to dict used in jinja2 templates + Not required to be covered by unit tests cause contains only technical features. + """ + + def __init__(self): + self.logger = logging.getLogger(self.__class__.__name__) + self._env = None + self.paths_named = namedtuple('paths_named', 'path_to_enum_class path_to_struct_class path_to_request_class ' + 'path_to_response_class path_to_notification_class enums_dir_name ' + 'structs_dir_name functions_dir_name rpc_creator') + + @property + def env(self): + """ + :return: jinja2 Environment + """ + return self._env + + @env.setter + def env(self, value): + """ + :param value: path with directory with templates + :return: jinja2 Environment + """ + if not Path(value).exists(): + self.logger.critical('Directory with templates not found %s', value) + sys.exit(1) + else: + self._env = Environment(loader=FileSystemLoader(value)) + + @property + def get_version(self): + """ + :return: current version of Generator + """ + return InterfaceProducerCommon.version + + def config_logging(self, verbose): + """ + Configure logging + :param verbose: boolean + """ + handler = logging.StreamHandler() + handler.setFormatter(logging.Formatter(fmt='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + datefmt='%m-%d %H:%M')) + if verbose: + handler.setLevel(logging.DEBUG) + self.logger.setLevel(logging.DEBUG) + else: + handler.setLevel(logging.ERROR) + self.logger.setLevel(logging.ERROR) + logging.getLogger().handlers.clear() + root_logger = logging.getLogger() + root_logger.addHandler(handler) + + def evaluate_output_directory(self, output_directory): + """ + :param output_directory: path to output_directory + :return: validated path to output_directory + """ + if output_directory.startswith('/'): + path = Path(output_directory).absolute().resolve() + else: + path = ROOT.joinpath(output_directory).resolve() + if not path.exists(): + self.logger.warning('Directory not found: %s, trying to create it', path) + try: + path.mkdir(parents=True, exist_ok=True) + except OSError as message1: + self.logger.critical('Failed to create directory %s, %s', path.as_posix(), message1) + sys.exit(1) + return path + + def get_parser(self): + """ + Parsing command-line arguments, or evaluating required Paths interactively. + :return: an instance of argparse.ArgumentParser + """ + + if len(sys.argv) == 2 and sys.argv[1] in ('-v', '--version'): + print(self.get_version) + sys.exit(0) + + Paths = namedtuple('Paths', 'name path') + xml = Paths('source_xml', ROOT.parents[0].joinpath('lib/rpc_spec/MOBILE_API.xml')) + required_source = not xml.path.exists() + + out = Paths('output_directory', ROOT.parents[0].joinpath('lib/js/src/rpc')) + output_required = not out.path.exists() + + parser = ArgumentParser(description='Proxy Library RPC Generator') + parser.add_argument('-v', '--version', action='store_true', help='print the version and exit') + parser.add_argument('-xml', '--source-xml', '--input-file', required=required_source, + help='should point to MOBILE_API.xml') + parser.add_argument('-xsd', '--source-xsd', required=False) + parser.add_argument('-d', '--output-directory', required=output_required, + help='define the place where the generated output should be placed') + parser.add_argument('-t', '--templates-directory', nargs='?', default=ROOT.joinpath('templates').as_posix(), + help='path to directory with templates') + parser.add_argument('-r', '--regex-pattern', required=False, + help='only elements matched with defined regex pattern will be parsed and generated') + parser.add_argument('--verbose', action='store_true', help='display additional details like logs etc') + parser.add_argument('-e', '--enums', required=False, action='store_true', + help='only specified elements will be generated, if present') + parser.add_argument('-s', '--structs', required=False, action='store_true', + help='only specified elements will be generated, if present') + parser.add_argument('-m', '-f', '--functions', required=False, action='store_true', + help='only specified elements will be generated, if present') + parser.add_argument('-y', '--overwrite', action='store_true', + help='force overwriting of existing files in output directory, ignore confirmation message') + parser.add_argument('-n', '--skip', action='store_true', + help='skip overwriting of existing files in output directory, ignore confirmation message') + + args, unknown = parser.parse_known_args() + + if unknown: + self.logger.critical('found unknown arguments: %s', ' '.join(unknown)) + parser.print_help(sys.stderr) + sys.exit(1) + + if args.skip and args.overwrite: + self.logger.critical('please select only one option skip or overwrite') + sys.exit(1) + + if not args.enums and not args.structs and not args.functions: + args.enums = args.structs = args.functions = True + + for intermediate in (xml, out): + if not getattr(args, intermediate.name) and intermediate.path.exists(): + while True: + try: + confirm = input('Confirm default path {} for {} Y/Enter = yes, N = no' + .format(intermediate.path, intermediate.name)) + if confirm.lower() == 'y' or not confirm: + self.logger.warning('%s set to %s', intermediate.name, intermediate.path) + setattr(args, intermediate.name, intermediate.path.as_posix()) + sleep(0.05) + break + if confirm.lower() == 'n': + self.logger.warning('provide argument %s', intermediate.name) + sys.exit(1) + except KeyboardInterrupt: + print('\nThe user interrupted the execution of the program') + sys.exit(1) + + args.output_directory = self.evaluate_output_directory(args.output_directory) + + self.logger.info('parsed arguments:\n%s', pformat((vars(args)))) + return args + + def versions_compatibility_validating(self): + """version of generator script requires the same or lesser version of parser script. + if the parser script needs to fix a bug (and becomes, e.g. 1.0.1) and the generator script stays at 1.0.0. + As long as the generator script is the same or greater major version, it should be parsable. + This requires some level of backward compatibility. E.g. they have to be the same major version. + + """ + + regex = r'(\d+\.\d+).(\d)' + + parser_origin = Parser().get_version + parser_split = re.findall(regex, parser_origin).pop() + generator_split = re.findall(regex, self.get_version).pop() + + parser_major = float(parser_split[0]) + generator_major = float(generator_split[0]) + + if parser_major > generator_major: + self.logger.critical('Generator (%s) requires the same or lesser version of Parser (%s)', + self.get_version, parser_origin) + sys.exit(1) + + self.logger.info('Parser type: %s, version %s,\tGenerator version %s', + basename(getfile(Parser().__class__)), parser_origin, self.get_version) + + def get_paths(self, file_name=ROOT.joinpath('paths.ini')): + """ + :param file_name: path to file with Paths + :return: namedtuple with Paths to key elements + """ + data = {} + try: + with file_name.open('r') as file: + for line in file: + if line.startswith('#'): + self.logger.warning('commented property %s, which will be skipped', line.strip()) + continue + if re.match(r'^(\w+)\s?=\s?(.+)', line): + if len(line.split('=')) > 2: + self.logger.critical('can not evaluate value, too many separators %s', str(line)) + sys.exit(1) + name, var = line.partition('=')[::2] + if name.strip() in data: + self.logger.critical('duplicate key %s', name) + sys.exit(1) + data[name.strip().lower()] = var.strip() + except FileNotFoundError as message1: + self.logger.critical(message1) + sys.exit(1) + + missed = list(set(self.paths_named._fields) - set(data.keys())) + if missed: + self.logger.critical('in %s missed fields: %s ', file, str(missed)) + sys.exit(1) + + return self.paths_named(**data) + + def get_mappings(self, file_name=ROOT.joinpath('mapping.json')): + """ + The key name in *.json is equal to property named in jinja2 templates + :param file_name: path to file with manual mappings + :return: dictionary with custom manual mappings + """ + + try: + with file_name.open('r') as file: + intermediate = file.readlines() + return loads(''.join(intermediate)) + except (FileNotFoundError, JSONDecodeError) as message1: + self.logger.error(message1) + return {} + + def write_file(self, file_name, template, data): + """ + Calling producer/transformer instance to transform initial Model to dict used in jinja2 templates. + Applying transformed dict to jinja2 templates and writing to appropriate file + :param file_name: output js file + :param template: name of template + :param data: transformed moder ready for apply to Jinja2 template + """ + try: + render = self.env.get_template(template).render(data) + with file_name.open('w', encoding='utf-8') as file: + file.write(render) + except (TemplateNotFound, UndefinedError, AttributeError) as message1: + self.logger.error('skipping %s, %s', file_name.as_posix(), message1) + + def process(self, directory, skip, overwrite, items, transformer): + """ + Process each item from initial Model. According to provided arguments skipping, overriding or asking what to to. + :param directory: output directory for writing output files + :param skip: if file exist skip it + :param overwrite: if file exist overwrite it + :param items: elements initial Model + :param transformer: producer/transformer instance + """ + directory.mkdir(parents=True, exist_ok=True) + for item in items.values(): + data = transformer.transform(item) + if 'template' in data: + template = data['template'] + else: + template = type(item).__name__.lower() + '_template.js' + file = directory.joinpath(data['name'] + '.js') + self.process_common(skip, overwrite, file, template, data) + + def process_function_name(self, file, dir_name, skip, overwrite, functions, transformer, mappings): + """ + :param file: + :param dir_name: + :param skip: + :param overwrite: + :param functions: + :param transformer: + :param mappings: + :return: + """ + if dir_name.startswith('..'): + dir_name = dir_name[1:] + + creator = namedtuple('creator', 'function_name class_name type') + data = {'name': file.stem, 'imports': [], 'cases': [], 'year': date.today().year, } + + grouped = [{'name': k, 'type': [x for x in v]} for k, v in groupby(functions.values(), key=lambda x: x.name)] + + for item in grouped: + name = item['name'] + for func in item['type']: + kind = func.message_type.name.capitalize() + if kind == 'Response': + name += kind + key = name + kind + if key in mappings and 'name' in mappings[key]: + name = mappings[key]['name'] + data['imports'].append(transformer.imports(what=name, wherefrom='{}/{}.js'.format(dir_name, name))) + if kind != 'Response': + data['cases'].append(creator(name, name, kind.upper())) + elif kind == 'Response' and len(item['type']) == 1: + data['cases'].append(creator(item['name'], name, kind.upper())) + + self.process_common(skip, overwrite, file, file.stem + '_template.js', data) + + def process_common(self, skip, overwrite, file, template, data): + """ + :param skip: + :param overwrite: + :param file: + :param template: + :param data: + :return: + """ + if file.is_file(): + if skip: + self.logger.info('Skipping %s', file.name) + return + if overwrite: + self.logger.info('Overriding %s', file.name) + self.write_file(file, template, data) + else: + while True: + try: + confirm = input('File already exists {}. Overwrite? Y/Enter = yes, N = no\n' + .format(file.name)) + if confirm.lower() == 'y' or not confirm: + self.logger.info('Overriding %s', file.name) + self.write_file(file, template, data) + break + if confirm.lower() == 'n': + self.logger.info('Skipping %s', file.name) + break + except KeyboardInterrupt: + print('\nThe user interrupted the execution of the program') + sys.exit(1) + else: + self.logger.info('Writing new %s', file.name) + self.write_file(file, template, data) + + def filter_pattern(self, interface, pattern): + """ + :param interface: initial Model + :param pattern: regex-pattern from command-line arguments to filter element from initial Model + :return: initial Model + """ + names = tuple(interface.enums.keys()) + tuple(interface.structs.keys()) + + if pattern: + match = {i: {} for i in vars(interface).keys()} + match['params'] = interface.params + empty = True + for key, value in vars(interface).items(): + if key == 'params': + continue + for name, item in value.items(): + if re.match(pattern, item.name): + if hasattr(item, 'message_type'): + log = '{}/{} {} match with {}'.format( + key, item.name, item.message_type.name.title(), pattern) + else: + log = '{}/{} match with {}'.format(key, item.name, pattern) + self.logger.info(log) + if key in match: + match[key][name] = item + empty = False + if empty: + self.logger.warning('no one match with %s', pattern) + sys.exit(0) + return Interface(**match), names + return interface, names + + @staticmethod + def evaluate_instance_directory(dir_name): + """ + :param dir_name: property from paths.ini (ENUMS|STRUCTS|FUNCTIONS)_DIR_NAME + :return: substring after float dot + """ + pattern = re.search(r'^([./]*)(.+)', dir_name) + if pattern: + return pattern.group(2) + raise GenerateError('Can not evaluate directory {}'.format(dir_name)) + + def main(self): + """ + Entry point for parser and generator + :return: None + """ + args = self.get_parser() + self.config_logging(args.verbose) + self.env = args.templates_directory + + self.versions_compatibility_validating() + + paths = self.get_paths() + + try: + interface = Parser().parse(args.source_xml, args.source_xsd) + except ParseError as error1: + self.logger.error(error1) + sys.exit(1) + + filtered, names = self.filter_pattern(interface, args.regex_pattern) + + mappings = self.get_mappings() + + functions_transformer = FunctionsProducer(paths, names, mappings) + if args.enums and filtered.enums: + directory = args.output_directory.joinpath(self.evaluate_instance_directory(paths.enums_dir_name)) + self.process(directory, args.skip, args.overwrite, filtered.enums, + EnumsProducer(paths, mappings)) + if args.structs and filtered.structs: + directory = args.output_directory.joinpath(self.evaluate_instance_directory(paths.structs_dir_name)) + self.process(directory, args.skip, args.overwrite, filtered.structs, + StructsProducer(paths, names, mappings)) + if args.functions and filtered.functions: + directory = args.output_directory.joinpath(self.evaluate_instance_directory(paths.functions_dir_name)) + self.process(directory, args.skip, args.overwrite, filtered.functions, functions_transformer) + self.process_function_name(args.output_directory.joinpath(paths.rpc_creator), paths.functions_dir_name, + args.skip, args.overwrite, interface.functions, functions_transformer, + mappings.get('functions', {})) + + +if __name__ == '__main__': + Generator().main() diff --git a/generator/mapping.json b/generator/mapping.json new file mode 100644 index 00000000..2f928fea --- /dev/null +++ b/generator/mapping.json @@ -0,0 +1,79 @@ +{ + "structs": { + "Grid": { + "col": { + "methods": { + "method_title": "Column", + "key": "KEY_COLUMN" + }, + "params": { + "key": "KEY_COLUMN" + } + }, + "colspan": { + "methods": { + "method_title": "ColumnSpan", + "key": "KEY_COLUMN_SPAN" + }, + "params": { + "key": "KEY_COLUMN_SPAN" + } + }, + "rowspan": { + "methods": { + "method_title": "RowSpan", + "key": "KEY_ROW_SPAN" + }, + "params": { + "key": "KEY_ROW_SPAN" + } + }, + "levelspan": { + "methods": { + "method_title": "LevelSpan", + "key": "KEY_LEVEL_SPAN" + }, + "params": { + "key": "KEY_LEVEL_SPAN" + } + } + } + }, + "functions": { + "SetAppIconRequest": { + "syncFileName": { + "methods": { + "method_title": "FileName", + "key": "KEY_FILE_NAME" + }, + "params": { + "key": "KEY_FILE_NAME" + } + } + }, + "RegisterAppInterfaceRequest": { + "appID": { + "-methods": {} + }, + "params": [ + { + "key": "APP_ID_MAX_LENGTH", + "value": 10 + } + ], + "script": "templates/scripts/RegisterAppInterfaceRequest.js" + }, + "PutFileRequest": { + "syncFileName": { + "methods": { + "method_title": "FileName", + "key": "KEY_FILE_NAME" + }, + "params": { + "key": "KEY_FILE_NAME" + } + }, + "script": "templates/scripts/PutFileRequest.js" + } + } +} diff --git a/generator/paths.ini b/generator/paths.ini new file mode 100644 index 00000000..d16c3d9e --- /dev/null +++ b/generator/paths.ini @@ -0,0 +1,13 @@ +#sdl_javascript_suite/lib/js/util/ +PATH_TO_ENUM_CLASS = ../../util/Enum.js + +#sdl_javascript_suite/lib/js/rpc/ +PATH_TO_STRUCT_CLASS = ../RpcStruct.js +PATH_TO_REQUEST_CLASS = ../RpcRequest.js +PATH_TO_RESPONSE_CLASS = ../RpcResponse.js +PATH_TO_NOTIFICATION_CLASS = ../RpcNotification.js +ENUMS_DIR_NAME = ../enums +STRUCTS_DIR_NAME = ../structs +FUNCTIONS_DIR_NAME = ../messages + +RPC_CREATOR = RpcCreator.js \ No newline at end of file diff --git a/generator/requirements.txt b/generator/requirements.txt new file mode 100644 index 00000000..ffc507da --- /dev/null +++ b/generator/requirements.txt @@ -0,0 +1,5 @@ +xmlschema +Jinja2 +coverage +pathlib2 +pylint \ No newline at end of file diff --git a/generator/templates/RpcCreator_template.js b/generator/templates/RpcCreator_template.js new file mode 100644 index 00000000..0ad53233 --- /dev/null +++ b/generator/templates/RpcCreator_template.js @@ -0,0 +1,63 @@ +{% extends 'base_template.js' %} + +{%- block imports %} +// messages +{{-super()}} +// other +import { RpcType } from './enums/RpcType.js'; +import { FunctionID } from './enums/FunctionID.js'; +import { JsonRpcMarshaller } from './../util/JsonRpcMarshaller.js'; +import { BinaryFrameHeader } from './../protocol/BinaryFrameHeader.js'; +{% endblock -%} +{%- block body %} + /** + * Converts an SdlPacket to an RpcMessage + * @param {SdlPacket} sdlPacket + * @return {RpcMessage} + */ + static construct (sdlPacket) { + const payload = sdlPacket.getPayload(); + const binaryFrameHeader = BinaryFrameHeader.fromBinaryHeader(payload); + + let message; + const rpcType = binaryFrameHeader.getRpcType(); + const rpcName = RpcType.keyForValue(rpcType); + const correlationId = binaryFrameHeader.getCorrelationId(); + const functionId = binaryFrameHeader.getFunctionId(); + const functionName = FunctionID.keyForValue(functionId); + const bulkData = binaryFrameHeader.getBulkData(); + const jsonData = binaryFrameHeader.getJsonData(); + const params = { + parameters: JsonRpcMarshaller.unmarshall(jsonData), + }; + + switch (functionId) { + {%- for item in cases %} + case FunctionID.{{item.function_name}}: + if (rpcType === RpcType.{{item.type}}) { + message = new {{item.class_name}}(params); + }{% if item.type == 'REQUEST' %} else if (rpcType === RpcType.RESPONSE) { + message = new {{item.class_name}}Response(params); + } + {%- endif %} + break; + {%- endfor %} + default: + message = null; + } + + if (message === null || message === undefined) { // informs of missing classes + console.warn(`RpcCreator couldn't construct an RPC for the ${functionName} ${rpcName}`); + return null; + } + + if (rpcType === RpcType.REQUEST || rpcType === RpcType.RESPONSE) { + message.setCorrelationId(correlationId); + } + if (bulkData) { + message.setBulkData(bulkData); + } + + return message; + } +{% endblock -%} \ No newline at end of file diff --git a/generator/templates/base_struct_function.js b/generator/templates/base_struct_function.js new file mode 100644 index 00000000..6eaaa4f7 --- /dev/null +++ b/generator/templates/base_struct_function.js @@ -0,0 +1,74 @@ +{% extends 'base_template.js' %} + +{% block typedef %} +{%- if description is defined or deprecated is defined %} +/** + {% if description is defined -%} + {% for d in description -%} + * {{d}} + {% endfor -%} + {% endif -%} + {% if deprecated is defined -%} + * @deprecated + {% endif -%} + */ +{%- endif %} +{%- endblock %} +{% block body %} + /** + {% if deprecated is defined -%} + * @deprecated + {% endif -%} + * @constructor + */ +{%- block constructor %} +{% endblock -%} + {%- if script is defined %} +{{script|indent(4,True)}} +{% endif -%} + {% for method in methods %} + {% set len = method.type|length + method.param_name|length + 13 -%} + /** + {% if deprecated is defined -%} + * @deprecated + {% endif -%} + {% if not method.description -%} + * @param {{'%s%s%s %s'|format('{', method.type, '}', method.param_name)}} + {% else -%} + * {% for d in method.description -%} + {% if loop.index == 1 -%} + @param {{'%s%s%s %s - %s'|format('{', method.type, '}', method.param_name, d)}} + {% else -%} + * {{d|indent(len,True)}} + {% endif -%} {% endfor -%} + {% endif -%} + * @return {{'%s%s%s'|format('{', name, '}')}} + */ + set{{method.method_title}} ({{method.param_name}}) { + {%- if method.external %} + this.validateType({{method.external}}, {{method.param_name}}{{ ', true' if '[]' in method.type }}); + {%- endif %} + this.setParameter({{name}}.{{method.key}}, {{method.param_name}}); + return this; + } + + /** + {% if deprecated is defined -%} + * @deprecated + {% endif -%} + * @return {{'%s%s%s'|format('{', method.type, '}')}} + */ + get{{method.method_title}} () { + {%- if method.external %} + return this.getObject({{method.external}}, {{name}}.{{method.key}}); + {%- else %} + return this.getParameter({{name}}.{{method.key}}); + {%- endif %} + } +{% endfor -%} +{%- endblock %} +{% block properties -%} +{% for param in params %} +{{name}}.{{param.key}} = {{param.value}}; +{%- endfor %} +{%- endblock %} \ No newline at end of file diff --git a/generator/templates/base_template.js b/generator/templates/base_template.js new file mode 100644 index 00000000..a690ff56 --- /dev/null +++ b/generator/templates/base_template.js @@ -0,0 +1,45 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) {{year}}, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ +{% block imports -%} +{% for _import in imports %} +import {{'%s %s %s'|format('{', _import.what, '}')}} from '{{_import.wherefrom}}'; +{%- endfor %} +{% endblock -%} +{% block typedef -%}{%- endblock %} +class {{name}}{{' extends '+ extend if extend}} { +{%- block body %} +{% endblock -%} +} +{% block properties -%}{%- endblock %} + +export {{'%s %s %s'|format('{', name, '}')}}; diff --git a/generator/templates/enum_template.js b/generator/templates/enum_template.js new file mode 100644 index 00000000..948c1831 --- /dev/null +++ b/generator/templates/enum_template.js @@ -0,0 +1,68 @@ +{% extends 'base_template.js' %} +{% block typedef %} +/** + {% if description is defined -%} + {% for d in description -%} + * {{d}} + {% endfor -%} + {% endif -%} + {% if deprecated is defined -%} + * @deprecated + {% endif -%} + * @typedef {{'%s%s%s %s'|format('{', extend, '}', name)}} + * @property {Object} _MAP + */ +{%- endblock %} +{% block body %} + /** + {%- if deprecated is defined %} + * @deprecated + {%- endif %} + * @constructor + */ + constructor () { + super(); + } + {%- for method in methods %} + + /** + {%- if deprecated is defined %} + * @deprecated + {%- endif %} + {%- for d in method.description %} + * {{d}} + {%- endfor %} + * @return {{'%s%s%s'|format('{', method.type, '}')}} + */ + static get {{method.method_title}} () { + return {{name}}._MAP.{{method.method_title}}; + } + {%- endfor %} +{% if script is defined %} +{{script|indent(4,True)}} +{% endif %} + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return {{name}}._valueForKey(key, {{name}}._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return {{name}}._keyForValue(value, {{name}}._MAP); + } +{% endblock %} +{% block properties %} +{{name}}._MAP = Object.freeze({ +{%- for param in params %} + '{{param.key}}': {{param.value}}, +{%- endfor %} +}); +{%- endblock %} \ No newline at end of file diff --git a/generator/templates/function_template.js b/generator/templates/function_template.js new file mode 100644 index 00000000..549751c6 --- /dev/null +++ b/generator/templates/function_template.js @@ -0,0 +1,7 @@ +{% extends 'base_struct_function.js' %} +{% block constructor %} + constructor (store) { + super(store); + this.setFunctionName(FunctionID.{{ func }}); + } +{% endblock %} \ No newline at end of file diff --git a/generator/templates/scripts/PutFileRequest.js b/generator/templates/scripts/PutFileRequest.js new file mode 100644 index 00000000..7a3a53a9 --- /dev/null +++ b/generator/templates/scripts/PutFileRequest.js @@ -0,0 +1,18 @@ +// ------ Not part of the RPC spec itself ----- + +/** + * @param {Uint8Array} fileData + * @return {PutFile} + */ +setFileData (fileData) { + this.setBulkData(fileData); + return this; +} +/** + * @return {Uint8Array} + */ +getFileData () { + return this.getBulkData(); +} + +// ----------------- END ----------------------- \ No newline at end of file diff --git a/generator/templates/scripts/RegisterAppInterfaceRequest.js b/generator/templates/scripts/RegisterAppInterfaceRequest.js new file mode 100644 index 00000000..bfd44e71 --- /dev/null +++ b/generator/templates/scripts/RegisterAppInterfaceRequest.js @@ -0,0 +1,49 @@ +/** + * @param {String} fullAppId + * @return {RegisterAppInterface} + */ +setFullAppId (fullAppId) { + this.validateType(String, fullAppId); + + if (fullAppId !== null) { + fullAppId = fullAppId.toLowerCase(); + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, fullAppId); + let appID; + if (fullAppId.length <= RegisterAppInterface.APP_ID_MAX_LENGTH) { + appID = fullAppId; + } else { + appID = fullAppId.replace('-', '').substring(0, RegisterAppInterface.APP_ID_MAX_LENGTH); + } + this._setAppId(appID); + } else { + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, null); + } + + return this; +} + +/** + * @return {String} the app id + */ +getFullAppId () { + return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID); +} + +/** + * @param {String} appId - This method should not be accessed directly by developers. Only set the full ID and this + * param will be set. + * @return {RegisterAppInterface} + */ +_setAppId (appId) { + this.validateType(String, appId); + + this.setParameter(RegisterAppInterface.KEY_APP_ID, appId); + return this; +} + +/** + * @return {String} the app id + */ +getAppId () { + return this.getParameter(RegisterAppInterface.KEY_APP_ID); +} \ No newline at end of file diff --git a/generator/templates/struct_template.js b/generator/templates/struct_template.js new file mode 100644 index 00000000..d8027553 --- /dev/null +++ b/generator/templates/struct_template.js @@ -0,0 +1,6 @@ +{% extends 'base_struct_function.js' %} +{% block constructor %} + constructor (parameters) { + super(parameters); + } +{% endblock %} diff --git a/generator/test/__init__.py b/generator/test/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/generator/test/runner.py b/generator/test/runner.py new file mode 100644 index 00000000..c2b0ebab --- /dev/null +++ b/generator/test/runner.py @@ -0,0 +1,41 @@ +"""Main entry point to run all tests + +""" + +import sys +from pathlib import Path +from unittest import TestLoader, TestSuite, TextTestRunner + +PATH = Path(__file__).absolute() + +sys.path.append(PATH.parents[2].joinpath('lib/rpc_spec/InterfaceParser').as_posix()) +sys.path.append(PATH.parents[1].as_posix()) + +try: + from test_enums import TestEnumsProducer + from test_functions import TestFunctionsProducer + from test_structs import TestStructsProducer + from test_code_format_and_quality import CodeFormatAndQuality +except ModuleNotFoundError as message: + print('{}.\nProbably you did not initialize submodule'.format(message)) + sys.exit(1) + + +def main(): + """ + Main entry point to run all tests + """ + suite = TestSuite() + + suite.addTests(TestLoader().loadTestsFromTestCase(TestFunctionsProducer)) + suite.addTests(TestLoader().loadTestsFromTestCase(TestEnumsProducer)) + suite.addTests(TestLoader().loadTestsFromTestCase(TestStructsProducer)) + suite.addTests(TestLoader().loadTestsFromTestCase(CodeFormatAndQuality)) + + runner = TextTestRunner(verbosity=2) + test_result = runner.run(suite) + print(test_result) + + +if __name__ == '__main__': + main() diff --git a/generator/test/test_code_format_and_quality.py b/generator/test/test_code_format_and_quality.py new file mode 100755 index 00000000..45b12ca5 --- /dev/null +++ b/generator/test/test_code_format_and_quality.py @@ -0,0 +1,36 @@ +"""Interface model unit test + +""" + +import unittest +from os import walk +from os.path import join +from pathlib import Path + +from pylint.lint import Run + + +class CodeFormatAndQuality(unittest.TestCase): + MINIMUM_SCORE = 9 + + def setUp(self): + """Searching for all python files to be checked + + """ + self.list_of_files = [] + for (directory, _, filenames) in walk(Path(__file__).absolute().parents[1].as_posix()): + self.list_of_files += [join(directory, file) for file in filenames + if file.endswith('.py') and not file.startswith('test')] + self.list_of_files.append('--max-line-length=120') + + def test_check(self): + """Performing checks by PyLint + + """ + results = Run(self.list_of_files, do_exit=False) + score = results.linter.stats['global_note'] + self.assertGreaterEqual(score, self.MINIMUM_SCORE) + + +if __name__ == "__main__": + unittest.main() diff --git a/generator/test/test_enums.py b/generator/test/test_enums.py new file mode 100644 index 00000000..05106809 --- /dev/null +++ b/generator/test/test_enums.py @@ -0,0 +1,61 @@ +from collections import namedtuple +from datetime import date +from unittest import TestCase + +from model.enum import Enum +from model.enum_element import EnumElement +from transformers.enums_producer import EnumsProducer + + +class TestEnumsProducer(TestCase): + def setUp(self): + self.maxDiff = None + Prop = namedtuple('Prop', 'enums_dir_name structs_dir_name path_to_enum_class') + paths = Prop(enums_dir_name='../enums', + structs_dir_name='../structs', + path_to_enum_class='../../util/Enum.js') + self.producer = EnumsProducer(paths) + + def test_FunctionID(self): + item = Enum(name='FunctionID', elements={ + 'RESERVED': EnumElement(name='RESERVED', value=0), + 'RegisterAppInterfaceID': EnumElement(name='RegisterAppInterfaceID', hex_value=1), + 'PerformAudioPassThruID': EnumElement(name='PerformAudioPassThruID', hex_value=10) + }) + expected = { + 'name': 'FunctionID', + 'imports': {self.producer.imports(what='Enum', wherefrom='../../util/Enum.js')}, + 'methods': [self.producer.methods(method_title='RESERVED', + description=[], type='Number'), + self.producer.methods(method_title='RegisterAppInterface', + description=[], type='Number'), + self.producer.methods(method_title='PerformAudioPassThru', + description=[], type='Number')], + 'params': [self.producer.params(key='RESERVED', value=0), + self.producer.params(key='RegisterAppInterface', value='0x01'), + self.producer.params(key='PerformAudioPassThru', value='0x10')], + 'extend': 'Enum' + } + result = self.producer.transform(item) + self.assertEqual(expected['name'], result['name']) + self.assertListEqual(sorted(expected['imports']), sorted(result['imports'])) + self.assertListEqual(sorted(expected['methods']), sorted(result['methods'])) + self.assertListEqual(sorted(expected['params']), sorted(result['params'])) + self.assertEqual(expected['extend'], result['extend']) + + def test_Result(self): + item = Enum(name='Result', elements={ + 'SUCCESS': EnumElement(name='SUCCESS') + }) + expected = { + 'year': date.today().year, + 'name': 'Result', + 'file_name': 'Result', + 'imports': {self.producer.imports(what='Enum', wherefrom='../../util/Enum.js')}, + 'methods': tuple([self.producer.methods(method_title='SUCCESS', + description=[], type='String')]), + 'params': tuple([self.producer.params(key='SUCCESS', value="'SUCCESS'")]), + 'extend': 'Enum' + } + result = self.producer.transform(item) + self.assertEqual(expected, result) diff --git a/generator/test/test_functions.py b/generator/test/test_functions.py new file mode 100644 index 00000000..eaa1ffaf --- /dev/null +++ b/generator/test/test_functions.py @@ -0,0 +1,261 @@ +from collections import namedtuple +from unittest import TestCase + +from model.array import Array +from model.boolean import Boolean +from model.enum import Enum +from model.enum_element import EnumElement +from model.function import Function +from model.integer import Integer +from model.param import Param +from model.string import String +from model.struct import Struct +from transformers.functions_producer import FunctionsProducer + + +class TestFunctionsProducer(TestCase): + def setUp(self): + self.maxDiff = None + Prop = namedtuple('Prop', + 'functions_dir_name enums_dir_name structs_dir_name path_to_request_class ' + 'path_to_response_class path_to_notification_class') + paths = Prop(functions_dir_name='../messages', + enums_dir_name='../enums', + structs_dir_name='../structs', + path_to_request_class='../RpcRequest.js', + path_to_response_class='../RpcResponse.js', + path_to_notification_class='../RpcNotification.js') + + mapping = {"functions": { + "RegisterAppInterfaceRequest": { + "syncMsgVersion": { + "methods": { + "method_title": "SdlMsgVersion", + "external": "SdlMsgVersion", + "key": "KEY_SDL_MSG_VERSION", + "type": "SdlMsgVersion" + }, + "params": { + "key": "KEY_SDL_MSG_VERSION" + } + }, + "params": [ + { + "key": "APP_ID_MAX_LENGTH", + "value": 10 + } + ] + }, + "RegisterAppInterfaceResponse": { + "script": "templates/scripts/notExist.js" + }, + "PutFileRequest": { + "script": "templates/scripts/PutFileRequest.js" + }}} + + names = ('FileType', 'Language', 'SyncMsgVersion', 'TemplateColorScheme', 'TTSChunk', 'Choice') + self.producer = FunctionsProducer(paths, names, mapping) + + def test_RegisterAppInterfaceRequest(self): + item = Function(name='RegisterAppInterface', function_id=Enum(name='RegisterAppInterfaceID'), + message_type=EnumElement(name='request'), params= + { + 'syncMsgVersion': Param(name='syncMsgVersion', param_type= + Struct(name='SyncMsgVersion', description=['Specifies the'], members={ + 'majorVersion': Param(name='majorVersion', param_type=Integer()) + }), description=['See SyncMsgVersion']), + 'fullAppID': Param(name='fullAppID', description=['ID used'], param_type=String()), + 'dayColorScheme': Param(name='dayColorScheme', param_type= + Struct(name='TemplateColorScheme', description= + ['\n A color scheme for all display layout templates.\n '])), + 'ttsName': Param(name='ttsName', description=['\n TTS string for'], param_type= + Array(element_type=Struct(name='TTSChunk', description=['A TTS chunk']))) + }) + expected = { + 'name': 'RegisterAppInterface', + 'imports': {self.producer.imports(what='SdlMsgVersion', wherefrom='../structs/SdlMsgVersion.js'), + self.producer.imports(what='TemplateColorScheme', + wherefrom='../structs/TemplateColorScheme.js'), + self.producer.imports(what='TTSChunk', wherefrom='../structs/TTSChunk.js'), + self.producer.imports(what='RpcRequest', wherefrom='../RpcRequest.js'), + self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js')}, + 'methods': [self.producer.methods(key='KEY_SDL_MSG_VERSION', + method_title='SdlMsgVersion', external='SdlMsgVersion', + description=['See SyncMsgVersion'], param_name='version', + type='SdlMsgVersion'), + self.producer.methods(key='KEY_FULL_APP_ID', method_title='FullAppID', + external=None, description=['ID used'], param_name='id', type='String'), + self.producer.methods(key='KEY_DAY_COLOR_SCHEME', param_name='scheme', + method_title='DayColorScheme', external='TemplateColorScheme', + description=['A color scheme for all display layout templates.'], + type='TemplateColorScheme'), + self.producer.methods(key='KEY_TTS_NAME', param_name='name', + method_title='TtsName', external='TTSChunk', + description=['TTS string for'], type='TTSChunk[]')], + 'params': [self.producer.params(key='APP_ID_MAX_LENGTH', value=10), + self.producer.params(key='KEY_SDL_MSG_VERSION', value="'syncMsgVersion'"), + self.producer.params(key='KEY_FULL_APP_ID', value="'fullAppID'"), + self.producer.params(key='KEY_DAY_COLOR_SCHEME', value="'dayColorScheme'"), + self.producer.params(key='KEY_TTS_NAME', value="'ttsName'")], + 'script': self.producer.get_file_content('templates/scripts/fullAppID.js'), + 'func': 'RegisterAppInterface', + 'extend': 'RpcRequest' + } + result = self.producer.transform(item) + self.assertEqual(expected['name'], result['name']) + self.assertListEqual(sorted(expected['imports']), sorted(result['imports'])) + self.assertListEqual(sorted(expected['methods']), sorted(result['methods'])) + self.assertListEqual(sorted(expected['params']), sorted(result['params'])) + self.assertEqual(expected['func'], result['func']) + self.assertEqual(expected['extend'], result['extend']) + + def test_RegisterAppInterfaceResponse(self): + item = Function(name='RegisterAppInterface', function_id=Enum(name='RegisterAppInterfaceID'), + description=['The response '], + message_type=EnumElement(name='response'), params= + { + 'success': Param(name='success', param_type=Boolean(), description=[' true if ']), + 'language': Param(name='language', param_type= + Enum(name='Language', elements={ + 'EN-US': EnumElement(name='EN-US', description=['English - US']) + }), description=['The currently']), + 'supportedDiagModes': Param(name='supportedDiagModes', param_type= + Array(element_type=Integer()), description=['\n Specifies the'], ) + }) + expected = { + 'name': 'RegisterAppInterfaceResponse', + 'imports': {self.producer.imports(what='Language', wherefrom='../enums/Language.js'), + self.producer.imports(what='RpcResponse', wherefrom='../RpcResponse.js'), + self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js')}, + 'methods': [self.producer.methods(key='KEY_LANGUAGE', + method_title='Language', external='Language', + description=['The currently'], param_name='language', + type='Language'), + self.producer.methods(key='KEY_SUPPORTED_DIAG_MODES', + method_title='SupportedDiagModes', external=None, + description=['Specifies the'], param_name='modes', + type='Number[]')], + 'params': [self.producer.params(key='KEY_LANGUAGE', value="'language'"), + self.producer.params(key='KEY_SUPPORTED_DIAG_MODES', value="'supportedDiagModes'")], + 'description': ['The response'], + 'func': 'RegisterAppInterface', + 'extend': 'RpcResponse' + } + result = self.producer.transform(item) + self.assertEqual(expected['name'], result['name']) + self.assertListEqual(sorted(expected['imports']), sorted(result['imports'])) + self.assertListEqual(sorted(expected['methods']), sorted(result['methods'])) + self.assertListEqual(sorted(expected['params']), sorted(result['params'])) + self.assertEqual(expected['description'], result['description']) + self.assertEqual(expected['func'], result['func']) + self.assertEqual(expected['extend'], result['extend']) + + def test_UnregisterAppInterfaceRequest(self): + item = Function(name='UnregisterAppInterface', function_id=Enum(name='UnregisterAppInterfaceID'), + message_type=EnumElement(name='request'), params={}) + expected = { + 'name': 'UnregisterAppInterface', + 'imports': {self.producer.imports(what='RpcRequest', wherefrom='../RpcRequest.js'), + self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js')}, + 'func': 'UnregisterAppInterface', + 'extend': 'RpcRequest' + } + result = self.producer.transform(item) + self.assertEqual(expected['name'], result['name']) + self.assertListEqual(sorted(expected['imports']), sorted(result['imports'])) + self.assertEqual(expected['func'], result['func']) + self.assertEqual(expected['extend'], result['extend']) + + def test_PutFileRequest(self): + item = Function(name='PutFile', function_id=Enum(name='PutFileID'), description=['\n Used to'], + message_type=EnumElement(name='request'), params= + { + 'fileType': Param(name='fileType', param_type= + Enum(name='FileType', description=['Enumeration listing'], elements={ + 'AUDIO_MP3': EnumElement(name='AUDIO_MP3') + }), description=['Selected file type.']) + }) + expected = { + 'name': 'PutFile', + 'imports': {self.producer.imports(what='FileType', wherefrom='../enums/FileType.js'), + self.producer.imports(what='RpcRequest', wherefrom='../RpcRequest.js'), + self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js')}, + 'methods': [self.producer.methods(key='KEY_FILE_TYPE', + method_title='FileType', external='FileType', + description=['Selected file type.'], param_name='type', + type='FileType')], + 'params': [self.producer.params(key='KEY_FILE_TYPE', value="'fileType'")], + 'description': ['Used to'], + 'script': self.producer.get_file_content('templates/scripts/PutFileRequest.js'), + 'func': 'PutFile', + 'extend': 'RpcRequest' + } + result = self.producer.transform(item) + self.assertEqual(expected['name'], result['name']) + self.assertListEqual(sorted(expected['imports']), sorted(result['imports'])) + self.assertListEqual(sorted(expected['methods']), sorted(result['methods'])) + self.assertListEqual(sorted(expected['params']), sorted(result['params'])) + self.assertEqual(expected['description'], result['description']) + self.assertSequenceEqual(expected['script'], result['script']) + self.assertEqual(expected['func'], result['func']) + self.assertEqual(expected['extend'], result['extend']) + + def test_OnEncodedSyncPDataNotification(self): + item = Function(name='OnEncodedSyncPData', function_id=Enum(name='OnEncodedSyncPDataID'), + description=['\n Callback including \n'], + message_type=EnumElement(name='notification'), params= + { + 'URL': Param(name='URL', param_type=String(), description=['\n If ']) + }) + expected = { + 'name': 'OnEncodedSyncPData', + 'imports': {self.producer.imports(what='RpcNotification', wherefrom='../RpcNotification.js'), + self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js')}, + 'methods': [self.producer.methods(key='KEY_URL', + method_title='URL', external=None, + description=['If'], param_name='url', + type='String')], + 'params': [self.producer.params(key='KEY_URL', value="'URL'")], + 'description': ['Callback including'], + 'func': 'OnEncodedSyncPData', + 'extend': 'RpcNotification' + } + result = self.producer.transform(item) + self.assertEqual(expected['name'], result['name']) + self.assertListEqual(sorted(expected['imports']), sorted(result['imports'])) + self.assertListEqual(sorted(expected['methods']), sorted(result['methods'])) + self.assertListEqual(sorted(expected['params']), sorted(result['params'])) + self.assertEqual(expected['description'], result['description']) + self.assertEqual(expected['func'], result['func']) + self.assertEqual(expected['extend'], result['extend']) + + def test_CreateInteractionChoiceSetRequest(self): + item = Function(name='CreateInteractionChoiceSet', function_id=Enum(name='CreateInteractionChoiceSetID'), + description=['creates interaction'], + message_type=EnumElement(name='request'), params= + { + 'choiceSet': Param(name='choiceSet', param_type= + Array(element_type=Struct(name='Choice', description=['A choice is an option given to ']))) + }) + expected = { + 'name': 'CreateInteractionChoiceSet', + 'imports': {self.producer.imports(what='Choice', wherefrom='../structs/Choice.js'), + self.producer.imports(what='RpcRequest', wherefrom='../RpcRequest.js'), + self.producer.imports(what='FunctionID', wherefrom='../enums/FunctionID.js')}, + 'methods': [self.producer.methods(key='KEY_CHOICE_SET', + method_title='ChoiceSet', external='Choice', + description=['A choice is an option given to'], param_name='set', + type='Choice[]')], + 'params': [self.producer.params(key='KEY_CHOICE_SET', value="'choiceSet'")], + 'description': ['creates interaction'], + 'func': 'CreateInteractionChoiceSet', + 'extend': 'RpcRequest' + } + result = self.producer.transform(item) + self.assertEqual(expected['name'], result['name']) + self.assertListEqual(sorted(expected['imports']), sorted(result['imports'])) + self.assertListEqual(sorted(expected['methods']), sorted(result['methods'])) + self.assertListEqual(sorted(expected['params']), sorted(result['params'])) + self.assertEqual(expected['description'], result['description']) + self.assertEqual(expected['func'], result['func']) + self.assertEqual(expected['extend'], result['extend']) diff --git a/generator/test/test_structs.py b/generator/test/test_structs.py new file mode 100644 index 00000000..c5110a29 --- /dev/null +++ b/generator/test/test_structs.py @@ -0,0 +1,37 @@ +from collections import namedtuple +from datetime import date +from unittest import TestCase + +from model.param import Param +from model.struct import Struct +from transformers.structs_producer import StructsProducer + + +class TestStructsProducer(TestCase): + def setUp(self): + self.maxDiff = None + Prop = namedtuple('Prop', 'structs_dir_name enums_dir_name path_to_struct_class') + paths = Prop(enums_dir_name='../enums', + structs_dir_name='../structs', + path_to_struct_class='../RpcStruct.js') + + self.producer = StructsProducer(paths, ['Image'], {}) + + def test_SoftButton(self): + item = Struct(name='SoftButton', members={ + 'image': Param(name='image', param_type=Struct(name='Image'), description=['Optional image']), + }) + expected = { + 'year': date.today().year, + 'name': 'SoftButton', + 'file_name': 'SoftButton', + 'imports': {self.producer.imports(what='Image', wherefrom='./Image.js'), + self.producer.imports(what='RpcStruct', wherefrom='../RpcStruct.js')}, + 'methods': tuple([self.producer.methods(description=['Optional image'], external='Image', + key='KEY_IMAGE', method_title='Image', + param_name='image', type='Image')]), + 'params': tuple([self.producer.params(key='KEY_IMAGE', value="'image'")]), + 'extend': 'RpcStruct' + } + result = self.producer.transform(item) + self.assertEqual(expected, result) diff --git a/generator/transformers/__init__.py b/generator/transformers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/generator/transformers/common_producer.py b/generator/transformers/common_producer.py new file mode 100644 index 00000000..a894e68e --- /dev/null +++ b/generator/transformers/common_producer.py @@ -0,0 +1,318 @@ +""" +Common transformation +""" + +import logging +import re +import textwrap +from abc import ABC +from collections import namedtuple, OrderedDict +from datetime import date +from pathlib import Path + +from model.array import Array +from model.enum import Enum +from model.float import Float +from model.function import Function +from model.integer import Integer +from model.struct import Struct +from transformers.generate_error import GenerateError + + +class InterfaceProducerCommon(ABC): + """ + Common transformation + """ + version = '1.0.0' + + def __init__(self, container_name, enums_dir_name, structs_dir_name, + names=(), mapping=OrderedDict()): + self.logger = logging.getLogger(self.__class__.__name__) + self.container_name = container_name + self.names = list(map(lambda e: self.replace_sync(e), names)) + self.enums_dir = enums_dir_name + self.structs_dir = structs_dir_name + self.mapping = mapping + self.imports = namedtuple('Imports', 'what wherefrom') + self.methods = namedtuple('Methods', 'key method_title external description param_name type') + self.params = namedtuple('Params', 'key value') + + @property + def get_version(self): + """ + :return: current version of Generator + """ + return self.version + + @staticmethod + def replace_sync(name): + """ + :param name: string with item name + :return: string with replaced 'sync' to 'Sdl' + """ + if name: + return re.sub(r'^(s|S)ync(.+)$', r'\1dl\2', name) + return name + + def transform(self, item) -> dict: + """ + :param item: particular element from initial Model + :return: dictionary to be applied to jinja2 template + """ + imports = {} + methods = {} + params = {} + + for param in getattr(item, self.container_name).values(): + _import, _methods, _params = self.common_flow(param, type(item)) + + if _import: + imports.update(_import) + if _methods: + methods[param.name] = _methods + params.update({param.name: _params}) + + name = self.replace_sync(item.name) + render = {'year': date.today().year, + 'file_name': name, + 'name': name, + 'imports': {self.imports(what=k, wherefrom=v) for k, v in imports.items()}, + 'methods': methods, + 'params': params} + + if getattr(item, 'description', None): + render.update({'description': self.extract_description(item.description, 116)}) + if item.deprecated: + render.update({'deprecated': item.deprecated}) + + self.custom_mapping(render, item) + + render.update({'params': tuple(render['params'].values())}) + render.update({'methods': tuple(render['methods'].values())}) + + return render + + def extract_imports(self, param, item_type): + """ + :param param: + :param item_type: + :return: + """ + + def evaluate(element): + if isinstance(element, (Struct, Enum)): + return self.replace_sync(element.name), type(element) + return None, None + + if isinstance(param.param_type, Array): + type_origin, kind = evaluate(param.param_type.element_type) + else: + type_origin, kind = evaluate(param.param_type) + + if type_origin in self.names: + if kind is Enum: + return {type_origin: '{}/{}.js'.format(self.enums_dir, type_origin)} + elif kind is Struct: + if item_type is Struct: + import_path = '.' + else: + import_path = self.structs_dir + return {type_origin: '{}/{}.js'.format(import_path, type_origin)} + + def common_flow(self, param, item_type): + """ + Main transformation flow, for Struct and Function + :param param: sub-element (Param, FunctionParam) of element from initial Model + :param item_type: type of parent element from initial Model + :return: tuple with 3 element, which going to be applied to jinja2 template + """ + name, description = self.extract_name_description(param) + type_name = self.extract_type(param) + imports = self.extract_imports(param, item_type) + param_name = self.replace_sync(param.name) + key = self.key(param_name) + + short_name = re.sub(r'(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])', '=^.^=', param_name) \ + .split('=^.^=').pop().lower() + description = self.extract_description(description, 100 - len(type_name) - len(short_name)) + title = param_name[:1].upper() + param_name[1:] + + methods = self.methods(key=key, method_title=title, external=name, description=description, + param_name=short_name, type=type_name) + params = self.params(key=key, value="'{}'".format(param.name)) + return imports, methods, params + + def prepare_imports(self, extend): + """ + Extract imports from property PATH_TO_(STRUCT|REQUEST|RESPONSE|NOTIFICATION)_CLASS + :param extend: property to be evaluated and converted to self.imports + :return: self.imports + """ + tmp = re.match(r'.+/(.+).js', extend) + if tmp: + return self.imports(what=tmp.group(1), wherefrom=extend) + raise GenerateError('Can not extract imports from {}'.format(extend)) + + @staticmethod + def key(param: str): + """ + Convert param string to uppercase and inserting underscores + :param param: camel case string + :return: string in uppercase with underscores + """ + if re.match(r'^[A-Z_]+$', param): + return 'KEY_' + param + return 'KEY_' + re.sub(r'([a-z]|[A-Z]{2,})([A-Z]|\d$)', r'\1_\2', param).upper() + + @staticmethod + def ending_cutter(name: str): + """ + If string not contains only uppercase letters and end with 'ID' deleting 'ID' from end of string + :param name: string to evaluate and deleting 'ID' from end of string + :return: if match cut string else original string + """ + if name.endswith('ID') and re.match(r'^(?=\w+[A-Z])(?=\w+[a-z])\w+$', name): + return name[:-2] + return name + + @staticmethod + def extract_description(data, length: int) -> list: + """ + Evaluate, align and delete @TODO + :param data: list with description + :param length: + :return: evaluated string + """ + if not data: + return [] + if isinstance(data, list): + data = ' '.join(data) + return textwrap.wrap(re.sub(r'(\s{2,}|\n|\[@TODO.+)', ' ', data).strip(), length) + + def extract_name_description(self, param): + """ + Extracting and evaluating name, description from appropriate place + :param param: sub-element (Param, FunctionParam) of element from initial Model + :return: tuple with 2 element (name, description) + """ + name = None + description = None + if getattr(param, 'description', None): + description = param.description + + if getattr(param, 'primary_name', None): + name = param.primary_name + elif getattr(param, 'param_type', None): + if getattr(param.param_type, 'name', None): + name = param.param_type.name + if not description and getattr(param.param_type, 'description', None): + description = param.param_type.description + elif getattr(param.param_type, 'element_type', None) and \ + getattr(param.param_type.element_type, 'name', None): + name = param.param_type.element_type.name + if not description and getattr(param.param_type.element_type, 'description', None): + description = param.param_type.element_type.description + + return self.replace_sync(name), self.extract_description(description, 116) + + def extract_type(self, param): + """ + Evaluate and extract type + :param param: sub-element (Param, FunctionParam) of element from initial Model + :return: string with sub-element type + """ + + def evaluate(instance): + if isinstance(instance, (Struct, Enum)): + return instance.name + if isinstance(instance, (Integer, Float)): + return 'Number' + return type(instance).__name__ + + if isinstance(param.param_type, Array): + return self.replace_sync(evaluate(param.param_type.element_type)) + '[]' + return self.replace_sync(evaluate(param.param_type)) + + def get_file_content(self, file_name: str): + """ + Used for getting content of custom scripts used in custom mapping + :param file_name: relational path custom scripts + :return: string with content of custom scripts + """ + file_name = Path(__file__).absolute().parents[1].joinpath(file_name) + try: + with file_name.open('r') as file: + intermediate = file.readlines() + return ''.join(intermediate) + except FileNotFoundError as message: + self.logger.error(message) + return '' + + def custom_mapping(self, render, item): + """ + :param render: dictionarry with data ready to apply to Jinja2 template + :param item: original item from parsed model + :return: + """ + if isinstance(item, Function): + mapping_name = item.name + item.message_type.name.capitalize() + else: + mapping_name = item.name + + if mapping_name not in self.mapping: + return + custom = self.mapping[mapping_name] + + if 'params' in custom: + for data in custom['params']: + missed = list(set(self.params._fields) - set(data.keys())) + if missed: + self.logger.warning('not valid %s', str(data)) + continue + render['params'][data['key']] = self.params(**data) + del custom['params'] + if 'script' in custom: + script = self.get_file_content(custom['script']) + if script: + render['script'] = script + del custom['script'] + + for name, mapping in custom.copy().items(): + if not isinstance(mapping, dict): + continue + for section, data in mapping.copy().items(): + if section == '-methods' and name in render['methods']: + redundant = list(custom[name].copy().keys()) + redundant.remove('-methods') + if redundant: + self.logger.info('%s/%s, "-methods" provided, skipping: %s', + mapping_name, name, str(redundant)) + del render['methods'][name] + del custom[name] + break + if section in render: + if section == 'imports': + for field in data: + missed = list(set(getattr(self, section)._fields) - set(field.keys())) + if missed: + self.logger.error('%s/%s/%s, redundant: %s', mapping_name, name, section, missed) + continue + render[section].add(self.imports(**field)) + elif name in render[section]: + redundant = list(set(data.keys()) - set(getattr(self, section)._fields)) + if redundant: + self.logger.error('%s/%s/%s, redundant: %s', mapping_name, name, section, redundant) + continue + if 'description' in data: + data['description'] = self.extract_description(data['description'], 116) + render[section][name] = render[section][name]._replace(**data) + else: + self.logger.warning('%s/%s not exist, skipping it.', mapping_name, name) + del custom[name][section] + else: + self.logger.warning('%s/%s/%s not exist, skipping it.', mapping_name, name, section) + del custom[name] + if name in custom and not custom[name]: + del custom[name] + + render.update(custom) diff --git a/generator/transformers/enums_producer.py b/generator/transformers/enums_producer.py new file mode 100644 index 00000000..f268b414 --- /dev/null +++ b/generator/transformers/enums_producer.py @@ -0,0 +1,86 @@ +""" +Enums transformation +""" + +import logging +from collections import namedtuple + +from model.enum import Enum +from model.enum_element import EnumElement +from transformers.common_producer import InterfaceProducerCommon + + +class EnumsProducer(InterfaceProducerCommon): + """ + Enums transformation + """ + + def __init__(self, paths, mapping=None): + super(EnumsProducer, self).__init__( + container_name='elements', + enums_dir_name=paths.enums_dir_name, + structs_dir_name=paths.structs_dir_name, + mapping=mapping['enums'] if mapping and 'enums' in mapping else {}) + self.logger = logging.getLogger(self.__class__.__name__) + self.enum_class = paths.path_to_enum_class + self.methods = namedtuple('Methods', 'method_title description type') + + def transform(self, item: Enum) -> dict: + """ + Override + :param item: particular element from initial Model + :return: dictionary to be applied to jinja2 template + """ + tmp = super(EnumsProducer, self).transform(item) + what_where = self.prepare_imports(self.enum_class) + tmp.update({'extend': what_where.what}) + tmp['imports'].add(what_where) + return tmp + + def common_flow(self, param: EnumElement, item_type=None): + """ + Override + Main transformation flow, for Enum + :param param: sub-element (EnumElement) of element from initial Model + :param item_type: not used + :return: tuple with 3 element, which going to be applied to jinja2 template + """ + (name, description) = self.extract_name_description(param) + type_name = self.extract_type(param) + description = self.extract_description(description, 117 - len(type_name)) + name = self.ending_cutter(name) + + methods = self.methods(method_title=name, description=description, type=type_name) + params = self.extract_param(param) + + imports = None + return imports, methods, params + + def extract_param(self, param: EnumElement) -> namedtuple: + """ + Evaluate and extract params + :param param: sub-element (EnumElement) of element from initial Model + :return: self.params + """ + if getattr(param, 'hex_value', None) is not None: + if len(str(param.hex_value)) > 1: + value = '0x{}'.format(param.hex_value) + else: + value = '0x0{}'.format(param.hex_value) + elif getattr(param, 'value', None) is not None: + value = param.value + else: + value = "'{}'".format(param.name) + return self.params(key=self.ending_cutter(param.primary_name), value=value) + + @staticmethod + def extract_type(param: EnumElement) -> str: + """ + Override + Evaluate and extract type + :param param: sub-element (EnumElement) of element from initial Model + :return: string with sub-element type + """ + if getattr(param, 'hex_value', None) is not None or getattr(param, 'value', None) is not None: + return 'Number' + return 'String' diff --git a/generator/transformers/functions_producer.py b/generator/transformers/functions_producer.py new file mode 100644 index 00000000..13836ba2 --- /dev/null +++ b/generator/transformers/functions_producer.py @@ -0,0 +1,51 @@ +""" +Functions transformation +""" +import logging + +from model.function import Function +from transformers.common_producer import InterfaceProducerCommon + + +class FunctionsProducer(InterfaceProducerCommon): + """ + Functions transformation + """ + + def __init__(self, paths, names, mapping=None): + super(FunctionsProducer, self).__init__( + container_name='params', + enums_dir_name=paths.enums_dir_name, + structs_dir_name=paths.structs_dir_name, + names=names, + mapping=mapping['functions'] if mapping and 'functions' in mapping else {}) + self.logger = logging.getLogger(self.__class__.__name__) + self.request_class = paths.path_to_request_class + self.response_class = paths.path_to_response_class + self.notification_class = paths.path_to_notification_class + + def transform(self, item: Function) -> dict: + """ + Override + :param item: particular element from initial Model + :return: dictionary to be applied to jinja2 template + """ + list(map(item.params.__delitem__, filter(item.params.__contains__, ['success', 'resultCode', 'info']))) + render = super(FunctionsProducer, self).transform(item) + render.update({'func': self.ending_cutter(item.function_id.name)}) + if item.message_type.name == 'response': + render.update({'file_name': item.name + item.message_type.name.capitalize()}) + name = None + if item.message_type.name == 'request': + name = self.request_class + elif item.message_type.name == 'response': + name = self.response_class + render['name'] = render['name'] + 'Response' + elif item.message_type.name == 'notification': + name = self.notification_class + if name: + what_where = self.prepare_imports(name) + render.update({'extend': what_where.what}) + render['imports'].add(what_where) + render['imports'].add(self.imports(what='FunctionID', wherefrom='{}/FunctionID.js'.format(self.enums_dir))) + return render diff --git a/generator/transformers/generate_error.py b/generator/transformers/generate_error.py new file mode 100644 index 00000000..3fe1a75e --- /dev/null +++ b/generator/transformers/generate_error.py @@ -0,0 +1,12 @@ +""" +Generate error. +""" + + +class GenerateError(Exception): + """Generate error. + + This exception is raised when generator is unable to create + output from given model. + + """ diff --git a/generator/transformers/structs_producer.py b/generator/transformers/structs_producer.py new file mode 100644 index 00000000..f5c90cf6 --- /dev/null +++ b/generator/transformers/structs_producer.py @@ -0,0 +1,36 @@ +""" +Structs transformation +""" + +import logging + +from model.struct import Struct +from transformers.common_producer import InterfaceProducerCommon + + +class StructsProducer(InterfaceProducerCommon): + """ + Structs transformation + """ + + def __init__(self, paths, names, mapping=None): + super(StructsProducer, self).__init__( + container_name='members', + enums_dir_name=paths.enums_dir_name, + structs_dir_name=paths.structs_dir_name, + names=names, + mapping=mapping['structs'] if mapping and 'structs' in mapping else {}) + self.logger = logging.getLogger(self.__class__.__name__) + self.struct_class = paths.path_to_struct_class + + def transform(self, item: Struct) -> dict: + """ + Override + :param item: particular element from initial Model + :return: dictionary to be applied to jinja2 template + """ + tmp = super(StructsProducer, self).transform(item) + what_where = self.prepare_imports(self.struct_class) + tmp.update({'extend': what_where.what}) + tmp['imports'].add(what_where) + return tmp diff --git a/lib/js/app.js b/lib/js/app.js index b2e0a776..3fb7ca96 100644 --- a/lib/js/app.js +++ b/lib/js/app.js @@ -51,76 +51,363 @@ import { RpcNotification } from './src/rpc/RpcNotification.js'; import { RpcRequest } from './src/rpc/RpcRequest.js'; import { RpcResponse } from './src/rpc/RpcResponse.js'; import { RpcStruct } from './src/rpc/RpcStruct.js'; +import { AmbientLightStatus } from './src/rpc/enums/AmbientLightStatus.js'; import { AppHMIType } from './src/rpc/enums/AppHMIType.js'; +import { AppInterfaceUnregisteredReason } from './src/rpc/enums/AppInterfaceUnregisteredReason.js'; +import { AppServiceType } from './src/rpc/enums/AppServiceType.js'; +import { AudioStreamingIndicator } from './src/rpc/enums/AudioStreamingIndicator.js'; import { AudioStreamingState } from './src/rpc/enums/AudioStreamingState.js'; import { AudioType } from './src/rpc/enums/AudioType.js'; import { BitsPerSample } from './src/rpc/enums/BitsPerSample.js'; +import { ButtonEventMode } from './src/rpc/enums/ButtonEventMode.js'; import { ButtonName } from './src/rpc/enums/ButtonName.js'; +import { ButtonPressMode } from './src/rpc/enums/ButtonPressMode.js'; +import { CarModeStatus } from './src/rpc/enums/CarModeStatus.js'; import { CharacterSet } from './src/rpc/enums/CharacterSet.js'; +import { CompassDirection } from './src/rpc/enums/CompassDirection.js'; +import { ComponentVolumeStatus } from './src/rpc/enums/ComponentVolumeStatus.js'; +import { DefrostZone } from './src/rpc/enums/DefrostZone.js'; +import { DeliveryMode } from './src/rpc/enums/DeliveryMode.js'; +import { DeviceLevelStatus } from './src/rpc/enums/DeviceLevelStatus.js'; +import { Dimension } from './src/rpc/enums/Dimension.js'; +import { Direction } from './src/rpc/enums/Direction.js'; +import { DisplayMode } from './src/rpc/enums/DisplayMode.js'; import { DisplayType } from './src/rpc/enums/DisplayType.js'; +import { DistanceUnit } from './src/rpc/enums/DistanceUnit.js'; +import { DriverDistractionState } from './src/rpc/enums/DriverDistractionState.js'; +import { ECallConfirmationStatus } from './src/rpc/enums/ECallConfirmationStatus.js'; +import { ElectronicParkBrakeStatus } from './src/rpc/enums/ElectronicParkBrakeStatus.js'; +import { EmergencyEventType } from './src/rpc/enums/EmergencyEventType.js'; import { FileType } from './src/rpc/enums/FileType.js'; +import { FuelCutoffStatus } from './src/rpc/enums/FuelCutoffStatus.js'; +import { FuelType } from './src/rpc/enums/FuelType.js'; import { FunctionID } from './src/rpc/enums/FunctionID.js'; +import { GlobalProperty } from './src/rpc/enums/GlobalProperty.js'; import { HMILevel } from './src/rpc/enums/HMILevel.js'; import { HmiZoneCapabilities } from './src/rpc/enums/HmiZoneCapabilities.js'; +import { HybridAppPreference } from './src/rpc/enums/HybridAppPreference.js'; +import { IgnitionStableStatus } from './src/rpc/enums/IgnitionStableStatus.js'; +import { IgnitionStatus } from './src/rpc/enums/IgnitionStatus.js'; import { ImageFieldName } from './src/rpc/enums/ImageFieldName.js'; import { ImageType } from './src/rpc/enums/ImageType.js'; +import { InteractionMode } from './src/rpc/enums/InteractionMode.js'; +import { KeyboardEvent } from './src/rpc/enums/KeyboardEvent.js'; +import { KeyboardLayout } from './src/rpc/enums/KeyboardLayout.js'; +import { KeypressMode } from './src/rpc/enums/KeypressMode.js'; import { Language } from './src/rpc/enums/Language.js'; +import { LayoutMode } from './src/rpc/enums/LayoutMode.js'; +import { LightName } from './src/rpc/enums/LightName.js'; +import { LightStatus } from './src/rpc/enums/LightStatus.js'; +import { MaintenanceModeStatus } from './src/rpc/enums/MaintenanceModeStatus.js'; +import { MassageCushion } from './src/rpc/enums/MassageCushion.js'; +import { MassageMode } from './src/rpc/enums/MassageMode.js'; +import { MassageZone } from './src/rpc/enums/MassageZone.js'; import { MediaClockFormat } from './src/rpc/enums/MediaClockFormat.js'; +import { MediaType } from './src/rpc/enums/MediaType.js'; +import { MenuLayout } from './src/rpc/enums/MenuLayout.js'; import { MetadataType } from './src/rpc/enums/MetadataType.js'; +import { ModuleType } from './src/rpc/enums/ModuleType.js'; +import { NavigationAction } from './src/rpc/enums/NavigationAction.js'; +import { NavigationJunction } from './src/rpc/enums/NavigationJunction.js'; +import { PRNDL } from './src/rpc/enums/PRNDL.js'; +import { PermissionStatus } from './src/rpc/enums/PermissionStatus.js'; +import { PowerModeQualificationStatus } from './src/rpc/enums/PowerModeQualificationStatus.js'; +import { PowerModeStatus } from './src/rpc/enums/PowerModeStatus.js'; +import { PredefinedLayout } from './src/rpc/enums/PredefinedLayout.js'; +import { PredefinedWindows } from './src/rpc/enums/PredefinedWindows.js'; import { PrerecordedSpeech } from './src/rpc/enums/PrerecordedSpeech.js'; +import { PrimaryAudioSource } from './src/rpc/enums/PrimaryAudioSource.js'; +import { RadioBand } from './src/rpc/enums/RadioBand.js'; +import { RadioState } from './src/rpc/enums/RadioState.js'; +import { RequestType } from './src/rpc/enums/RequestType.js'; import { Result } from './src/rpc/enums/Result.js'; import { RpcType } from './src/rpc/enums/RpcType.js'; import { SamplingRate } from './src/rpc/enums/SamplingRate.js'; +import { SeatMemoryActionType } from './src/rpc/enums/SeatMemoryActionType.js'; +import { ServiceUpdateReason } from './src/rpc/enums/ServiceUpdateReason.js'; import { SoftButtonType } from './src/rpc/enums/SoftButtonType.js'; import { SpeechCapabilities } from './src/rpc/enums/SpeechCapabilities.js'; +import { SupportedSeat } from './src/rpc/enums/SupportedSeat.js'; import { SystemAction } from './src/rpc/enums/SystemAction.js'; +import { SystemCapabilityType } from './src/rpc/enums/SystemCapabilityType.js'; import { SystemContext } from './src/rpc/enums/SystemContext.js'; +import { TBTState } from './src/rpc/enums/TBTState.js'; +import { TPMS } from './src/rpc/enums/TPMS.js'; +import { TemperatureUnit } from './src/rpc/enums/TemperatureUnit.js'; import { TextAlignment } from './src/rpc/enums/TextAlignment.js'; import { TextFieldName } from './src/rpc/enums/TextFieldName.js'; +import { TimerMode } from './src/rpc/enums/TimerMode.js'; +import { TouchType } from './src/rpc/enums/TouchType.js'; +import { TriggerSource } from './src/rpc/enums/TriggerSource.js'; +import { TurnSignal } from './src/rpc/enums/TurnSignal.js'; +import { UpdateMode } from './src/rpc/enums/UpdateMode.js'; +import { VehicleDataActiveStatus } from './src/rpc/enums/VehicleDataActiveStatus.js'; +import { VehicleDataEventStatus } from './src/rpc/enums/VehicleDataEventStatus.js'; +import { VehicleDataNotificationStatus } from './src/rpc/enums/VehicleDataNotificationStatus.js'; +import { VehicleDataResultCode } from './src/rpc/enums/VehicleDataResultCode.js'; +import { VehicleDataStatus } from './src/rpc/enums/VehicleDataStatus.js'; +import { VehicleDataType } from './src/rpc/enums/VehicleDataType.js'; +import { VentilationMode } from './src/rpc/enums/VentilationMode.js'; import { VideoStreamingCodec } from './src/rpc/enums/VideoStreamingCodec.js'; import { VideoStreamingProtocol } from './src/rpc/enums/VideoStreamingProtocol.js'; import { VideoStreamingState } from './src/rpc/enums/VideoStreamingState.js'; import { VrCapabilities } from './src/rpc/enums/VrCapabilities.js'; +import { WarningLightStatus } from './src/rpc/enums/WarningLightStatus.js'; +import { WayPointType } from './src/rpc/enums/WayPointType.js'; +import { WindowType } from './src/rpc/enums/WindowType.js'; +import { WiperStatus } from './src/rpc/enums/WiperStatus.js'; +import { messageType } from './src/rpc/enums/messageType.js'; import { AddCommand } from './src/rpc/messages/AddCommand.js'; import { AddCommandResponse } from './src/rpc/messages/AddCommandResponse.js'; -import { OnHmiStatus } from './src/rpc/messages/OnHmiStatus.js'; +import { AddSubMenu } from './src/rpc/messages/AddSubMenu.js'; +import { AddSubMenuResponse } from './src/rpc/messages/AddSubMenuResponse.js'; +import { Alert } from './src/rpc/messages/Alert.js'; +import { AlertManeuver } from './src/rpc/messages/AlertManeuver.js'; +import { AlertManeuverResponse } from './src/rpc/messages/AlertManeuverResponse.js'; +import { AlertResponse } from './src/rpc/messages/AlertResponse.js'; +import { ButtonPress } from './src/rpc/messages/ButtonPress.js'; +import { ButtonPressResponse } from './src/rpc/messages/ButtonPressResponse.js'; +import { CancelInteraction } from './src/rpc/messages/CancelInteraction.js'; +import { CancelInteractionResponse } from './src/rpc/messages/CancelInteractionResponse.js'; +import { ChangeRegistration } from './src/rpc/messages/ChangeRegistration.js'; +import { ChangeRegistrationResponse } from './src/rpc/messages/ChangeRegistrationResponse.js'; +import { CloseApplication } from './src/rpc/messages/CloseApplication.js'; +import { CloseApplicationResponse } from './src/rpc/messages/CloseApplicationResponse.js'; +import { CreateInteractionChoiceSet } from './src/rpc/messages/CreateInteractionChoiceSet.js'; +import { CreateInteractionChoiceSetResponse } from './src/rpc/messages/CreateInteractionChoiceSetResponse.js'; +import { CreateWindow } from './src/rpc/messages/CreateWindow.js'; +import { CreateWindowResponse } from './src/rpc/messages/CreateWindowResponse.js'; +import { DeleteCommand } from './src/rpc/messages/DeleteCommand.js'; +import { DeleteCommandResponse } from './src/rpc/messages/DeleteCommandResponse.js'; +import { DeleteFile } from './src/rpc/messages/DeleteFile.js'; +import { DeleteFileResponse } from './src/rpc/messages/DeleteFileResponse.js'; +import { DeleteInteractionChoiceSet } from './src/rpc/messages/DeleteInteractionChoiceSet.js'; +import { DeleteInteractionChoiceSetResponse } from './src/rpc/messages/DeleteInteractionChoiceSetResponse.js'; +import { DeleteSubMenu } from './src/rpc/messages/DeleteSubMenu.js'; +import { DeleteSubMenuResponse } from './src/rpc/messages/DeleteSubMenuResponse.js'; +import { DeleteWindow } from './src/rpc/messages/DeleteWindow.js'; +import { DeleteWindowResponse } from './src/rpc/messages/DeleteWindowResponse.js'; +import { DiagnosticMessage } from './src/rpc/messages/DiagnosticMessage.js'; +import { DiagnosticMessageResponse } from './src/rpc/messages/DiagnosticMessageResponse.js'; +import { DialNumber } from './src/rpc/messages/DialNumber.js'; +import { DialNumberResponse } from './src/rpc/messages/DialNumberResponse.js'; +import { EncodedSyncPData } from './src/rpc/messages/EncodedSyncPData.js'; +import { EncodedSyncPDataResponse } from './src/rpc/messages/EncodedSyncPDataResponse.js'; +import { EndAudioPassThru } from './src/rpc/messages/EndAudioPassThru.js'; +import { EndAudioPassThruResponse } from './src/rpc/messages/EndAudioPassThruResponse.js'; +import { GenericResponseResponse } from './src/rpc/messages/GenericResponseResponse.js'; +import { GetAppServiceData } from './src/rpc/messages/GetAppServiceData.js'; +import { GetAppServiceDataResponse } from './src/rpc/messages/GetAppServiceDataResponse.js'; +import { GetCloudAppProperties } from './src/rpc/messages/GetCloudAppProperties.js'; +import { GetCloudAppPropertiesResponse } from './src/rpc/messages/GetCloudAppPropertiesResponse.js'; +import { GetDTCs } from './src/rpc/messages/GetDTCs.js'; +import { GetDTCsResponse } from './src/rpc/messages/GetDTCsResponse.js'; +import { GetFile } from './src/rpc/messages/GetFile.js'; +import { GetFileResponse } from './src/rpc/messages/GetFileResponse.js'; +import { GetInteriorVehicleData } from './src/rpc/messages/GetInteriorVehicleData.js'; +import { GetInteriorVehicleDataConsent } from './src/rpc/messages/GetInteriorVehicleDataConsent.js'; +import { GetInteriorVehicleDataConsentResponse } from './src/rpc/messages/GetInteriorVehicleDataConsentResponse.js'; +import { GetInteriorVehicleDataResponse } from './src/rpc/messages/GetInteriorVehicleDataResponse.js'; +import { GetSystemCapability } from './src/rpc/messages/GetSystemCapability.js'; +import { GetSystemCapabilityResponse } from './src/rpc/messages/GetSystemCapabilityResponse.js'; +import { GetVehicleData } from './src/rpc/messages/GetVehicleData.js'; +import { GetVehicleDataResponse } from './src/rpc/messages/GetVehicleDataResponse.js'; +import { GetWayPoints } from './src/rpc/messages/GetWayPoints.js'; +import { GetWayPointsResponse } from './src/rpc/messages/GetWayPointsResponse.js'; +import { ListFiles } from './src/rpc/messages/ListFiles.js'; +import { ListFilesResponse } from './src/rpc/messages/ListFilesResponse.js'; +import { OnAppInterfaceUnregistered } from './src/rpc/messages/OnAppInterfaceUnregistered.js'; +import { OnAppServiceData } from './src/rpc/messages/OnAppServiceData.js'; +import { OnAudioPassThru } from './src/rpc/messages/OnAudioPassThru.js'; +import { OnButtonEvent } from './src/rpc/messages/OnButtonEvent.js'; +import { OnButtonPress } from './src/rpc/messages/OnButtonPress.js'; +import { OnCommand } from './src/rpc/messages/OnCommand.js'; +import { OnDriverDistraction } from './src/rpc/messages/OnDriverDistraction.js'; +import { OnEncodedSyncPData } from './src/rpc/messages/OnEncodedSyncPData.js'; +import { OnHMIStatus } from './src/rpc/messages/OnHMIStatus.js'; +import { OnHashChange } from './src/rpc/messages/OnHashChange.js'; +import { OnInteriorVehicleData } from './src/rpc/messages/OnInteriorVehicleData.js'; +import { OnKeyboardInput } from './src/rpc/messages/OnKeyboardInput.js'; import { OnLanguageChange } from './src/rpc/messages/OnLanguageChange.js'; +import { OnPermissionsChange } from './src/rpc/messages/OnPermissionsChange.js'; +import { OnRCStatus } from './src/rpc/messages/OnRCStatus.js'; +import { OnSystemCapabilityUpdated } from './src/rpc/messages/OnSystemCapabilityUpdated.js'; +import { OnSystemRequest } from './src/rpc/messages/OnSystemRequest.js'; +import { OnTBTClientState } from './src/rpc/messages/OnTBTClientState.js'; +import { OnTouchEvent } from './src/rpc/messages/OnTouchEvent.js'; +import { OnVehicleData } from './src/rpc/messages/OnVehicleData.js'; +import { OnWayPointChange } from './src/rpc/messages/OnWayPointChange.js'; +import { PerformAppServiceInteraction } from './src/rpc/messages/PerformAppServiceInteraction.js'; +import { PerformAppServiceInteractionResponse } from './src/rpc/messages/PerformAppServiceInteractionResponse.js'; +import { PerformAudioPassThru } from './src/rpc/messages/PerformAudioPassThru.js'; +import { PerformAudioPassThruResponse } from './src/rpc/messages/PerformAudioPassThruResponse.js'; +import { PerformInteraction } from './src/rpc/messages/PerformInteraction.js'; +import { PerformInteractionResponse } from './src/rpc/messages/PerformInteractionResponse.js'; +import { PublishAppService } from './src/rpc/messages/PublishAppService.js'; +import { PublishAppServiceResponse } from './src/rpc/messages/PublishAppServiceResponse.js'; import { PutFile } from './src/rpc/messages/PutFile.js'; import { PutFileResponse } from './src/rpc/messages/PutFileResponse.js'; +import { ReadDID } from './src/rpc/messages/ReadDID.js'; +import { ReadDIDResponse } from './src/rpc/messages/ReadDIDResponse.js'; import { RegisterAppInterface } from './src/rpc/messages/RegisterAppInterface.js'; import { RegisterAppInterfaceResponse } from './src/rpc/messages/RegisterAppInterfaceResponse.js'; +import { ReleaseInteriorVehicleDataModule } from './src/rpc/messages/ReleaseInteriorVehicleDataModule.js'; +import { ReleaseInteriorVehicleDataModuleResponse } from './src/rpc/messages/ReleaseInteriorVehicleDataModuleResponse.js'; +import { ResetGlobalProperties } from './src/rpc/messages/ResetGlobalProperties.js'; +import { ResetGlobalPropertiesResponse } from './src/rpc/messages/ResetGlobalPropertiesResponse.js'; +import { ScrollableMessage } from './src/rpc/messages/ScrollableMessage.js'; +import { ScrollableMessageResponse } from './src/rpc/messages/ScrollableMessageResponse.js'; +import { SendHapticData } from './src/rpc/messages/SendHapticData.js'; +import { SendHapticDataResponse } from './src/rpc/messages/SendHapticDataResponse.js'; +import { SendLocation } from './src/rpc/messages/SendLocation.js'; +import { SendLocationResponse } from './src/rpc/messages/SendLocationResponse.js'; import { SetAppIcon } from './src/rpc/messages/SetAppIcon.js'; import { SetAppIconResponse } from './src/rpc/messages/SetAppIconResponse.js'; +import { SetCloudAppProperties } from './src/rpc/messages/SetCloudAppProperties.js'; +import { SetCloudAppPropertiesResponse } from './src/rpc/messages/SetCloudAppPropertiesResponse.js'; +import { SetDisplayLayout } from './src/rpc/messages/SetDisplayLayout.js'; +import { SetDisplayLayoutResponse } from './src/rpc/messages/SetDisplayLayoutResponse.js'; +import { SetGlobalProperties } from './src/rpc/messages/SetGlobalProperties.js'; +import { SetGlobalPropertiesResponse } from './src/rpc/messages/SetGlobalPropertiesResponse.js'; +import { SetInteriorVehicleData } from './src/rpc/messages/SetInteriorVehicleData.js'; +import { SetInteriorVehicleDataResponse } from './src/rpc/messages/SetInteriorVehicleDataResponse.js'; +import { SetMediaClockTimer } from './src/rpc/messages/SetMediaClockTimer.js'; +import { SetMediaClockTimerResponse } from './src/rpc/messages/SetMediaClockTimerResponse.js'; import { Show } from './src/rpc/messages/Show.js'; +import { ShowAppMenu } from './src/rpc/messages/ShowAppMenu.js'; +import { ShowAppMenuResponse } from './src/rpc/messages/ShowAppMenuResponse.js'; +import { ShowConstantTBT } from './src/rpc/messages/ShowConstantTBT.js'; +import { ShowConstantTBTResponse } from './src/rpc/messages/ShowConstantTBTResponse.js'; import { ShowResponse } from './src/rpc/messages/ShowResponse.js'; +import { Slider } from './src/rpc/messages/Slider.js'; +import { SliderResponse } from './src/rpc/messages/SliderResponse.js'; +import { Speak } from './src/rpc/messages/Speak.js'; +import { SpeakResponse } from './src/rpc/messages/SpeakResponse.js'; +import { SubscribeButton } from './src/rpc/messages/SubscribeButton.js'; +import { SubscribeButtonResponse } from './src/rpc/messages/SubscribeButtonResponse.js'; +import { SubscribeVehicleData } from './src/rpc/messages/SubscribeVehicleData.js'; +import { SubscribeVehicleDataResponse } from './src/rpc/messages/SubscribeVehicleDataResponse.js'; +import { SubscribeWayPoints } from './src/rpc/messages/SubscribeWayPoints.js'; +import { SubscribeWayPointsResponse } from './src/rpc/messages/SubscribeWayPointsResponse.js'; +import { SystemRequest } from './src/rpc/messages/SystemRequest.js'; +import { SystemRequestResponse } from './src/rpc/messages/SystemRequestResponse.js'; +import { UnpublishAppService } from './src/rpc/messages/UnpublishAppService.js'; +import { UnpublishAppServiceResponse } from './src/rpc/messages/UnpublishAppServiceResponse.js'; import { UnregisterAppInterface } from './src/rpc/messages/UnregisterAppInterface.js'; import { UnregisterAppInterfaceResponse } from './src/rpc/messages/UnregisterAppInterfaceResponse.js'; +import { UnsubscribeButton } from './src/rpc/messages/UnsubscribeButton.js'; +import { UnsubscribeButtonResponse } from './src/rpc/messages/UnsubscribeButtonResponse.js'; +import { UnsubscribeVehicleData } from './src/rpc/messages/UnsubscribeVehicleData.js'; +import { UnsubscribeVehicleDataResponse } from './src/rpc/messages/UnsubscribeVehicleDataResponse.js'; +import { UnsubscribeWayPoints } from './src/rpc/messages/UnsubscribeWayPoints.js'; +import { UnsubscribeWayPointsResponse } from './src/rpc/messages/UnsubscribeWayPointsResponse.js'; +import { UpdateTurnList } from './src/rpc/messages/UpdateTurnList.js'; +import { UpdateTurnListResponse } from './src/rpc/messages/UpdateTurnListResponse.js'; +import { AirbagStatus } from './src/rpc/structs/AirbagStatus.js'; import { AppInfo } from './src/rpc/structs/AppInfo.js'; +import { AppServiceCapability } from './src/rpc/structs/AppServiceCapability.js'; +import { AppServiceData } from './src/rpc/structs/AppServiceData.js'; +import { AppServiceManifest } from './src/rpc/structs/AppServiceManifest.js'; +import { AppServiceRecord } from './src/rpc/structs/AppServiceRecord.js'; +import { AppServicesCapabilities } from './src/rpc/structs/AppServicesCapabilities.js'; +import { AudioControlCapabilities } from './src/rpc/structs/AudioControlCapabilities.js'; +import { AudioControlData } from './src/rpc/structs/AudioControlData.js'; import { AudioPassThruCapabilities } from './src/rpc/structs/AudioPassThruCapabilities.js'; +import { BeltStatus } from './src/rpc/structs/BeltStatus.js'; +import { BodyInformation } from './src/rpc/structs/BodyInformation.js'; import { ButtonCapabilities } from './src/rpc/structs/ButtonCapabilities.js'; +import { Choice } from './src/rpc/structs/Choice.js'; +import { ClimateControlCapabilities } from './src/rpc/structs/ClimateControlCapabilities.js'; +import { ClimateControlData } from './src/rpc/structs/ClimateControlData.js'; +import { CloudAppProperties } from './src/rpc/structs/CloudAppProperties.js'; +import { ClusterModeStatus } from './src/rpc/structs/ClusterModeStatus.js'; +import { Coordinate } from './src/rpc/structs/Coordinate.js'; +import { DIDResult } from './src/rpc/structs/DIDResult.js'; +import { DateTime } from './src/rpc/structs/DateTime.js'; import { DeviceInfo } from './src/rpc/structs/DeviceInfo.js'; +import { DeviceStatus } from './src/rpc/structs/DeviceStatus.js'; import { DisplayCapabilities } from './src/rpc/structs/DisplayCapabilities.js'; +import { DisplayCapability } from './src/rpc/structs/DisplayCapability.js'; +import { ECallInfo } from './src/rpc/structs/ECallInfo.js'; +import { EmergencyEvent } from './src/rpc/structs/EmergencyEvent.js'; +import { EqualizerSettings } from './src/rpc/structs/EqualizerSettings.js'; +import { FuelRange } from './src/rpc/structs/FuelRange.js'; +import { GPSData } from './src/rpc/structs/GPSData.js'; import { Grid } from './src/rpc/structs/Grid.js'; import { HMICapabilities } from './src/rpc/structs/HMICapabilities.js'; +import { HMIPermissions } from './src/rpc/structs/HMIPermissions.js'; +import { HMISettingsControlCapabilities } from './src/rpc/structs/HMISettingsControlCapabilities.js'; +import { HMISettingsControlData } from './src/rpc/structs/HMISettingsControlData.js'; +import { HapticRect } from './src/rpc/structs/HapticRect.js'; +import { HeadLampStatus } from './src/rpc/structs/HeadLampStatus.js'; import { Image } from './src/rpc/structs/Image.js'; import { ImageField } from './src/rpc/structs/ImageField.js'; import { ImageResolution } from './src/rpc/structs/ImageResolution.js'; +import { KeyboardProperties } from './src/rpc/structs/KeyboardProperties.js'; +import { LightCapabilities } from './src/rpc/structs/LightCapabilities.js'; +import { LightControlCapabilities } from './src/rpc/structs/LightControlCapabilities.js'; +import { LightControlData } from './src/rpc/structs/LightControlData.js'; +import { LightState } from './src/rpc/structs/LightState.js'; +import { LocationDetails } from './src/rpc/structs/LocationDetails.js'; +import { MassageCushionFirmness } from './src/rpc/structs/MassageCushionFirmness.js'; +import { MassageModeData } from './src/rpc/structs/MassageModeData.js'; +import { MediaServiceData } from './src/rpc/structs/MediaServiceData.js'; +import { MediaServiceManifest } from './src/rpc/structs/MediaServiceManifest.js'; import { MenuParams } from './src/rpc/structs/MenuParams.js'; import { MetadataTags } from './src/rpc/structs/MetadataTags.js'; +import { ModuleData } from './src/rpc/structs/ModuleData.js'; import { ModuleInfo } from './src/rpc/structs/ModuleInfo.js'; +import { MyKey } from './src/rpc/structs/MyKey.js'; +import { NavigationCapability } from './src/rpc/structs/NavigationCapability.js'; +import { NavigationInstruction } from './src/rpc/structs/NavigationInstruction.js'; +import { NavigationServiceData } from './src/rpc/structs/NavigationServiceData.js'; +import { NavigationServiceManifest } from './src/rpc/structs/NavigationServiceManifest.js'; +import { OASISAddress } from './src/rpc/structs/OASISAddress.js'; +import { ParameterPermissions } from './src/rpc/structs/ParameterPermissions.js'; +import { PermissionItem } from './src/rpc/structs/PermissionItem.js'; +import { PhoneCapability } from './src/rpc/structs/PhoneCapability.js'; import { PresetBankCapabilities } from './src/rpc/structs/PresetBankCapabilities.js'; import { RGBColor } from './src/rpc/structs/RGBColor.js'; +import { RadioControlCapabilities } from './src/rpc/structs/RadioControlCapabilities.js'; +import { RadioControlData } from './src/rpc/structs/RadioControlData.js'; +import { RdsData } from './src/rpc/structs/RdsData.js'; +import { Rectangle } from './src/rpc/structs/Rectangle.js'; +import { RemoteControlCapabilities } from './src/rpc/structs/RemoteControlCapabilities.js'; import { ScreenParams } from './src/rpc/structs/ScreenParams.js'; import { SdlMsgVersion } from './src/rpc/structs/SdlMsgVersion.js'; +import { SeatControlCapabilities } from './src/rpc/structs/SeatControlCapabilities.js'; +import { SeatControlData } from './src/rpc/structs/SeatControlData.js'; +import { SeatLocation } from './src/rpc/structs/SeatLocation.js'; +import { SeatLocationCapability } from './src/rpc/structs/SeatLocationCapability.js'; +import { SeatMemoryAction } from './src/rpc/structs/SeatMemoryAction.js'; +import { SingleTireStatus } from './src/rpc/structs/SingleTireStatus.js'; +import { SisData } from './src/rpc/structs/SisData.js'; import { SoftButton } from './src/rpc/structs/SoftButton.js'; import { SoftButtonCapabilities } from './src/rpc/structs/SoftButtonCapabilities.js'; +import { StartTime } from './src/rpc/structs/StartTime.js'; +import { StationIDNumber } from './src/rpc/structs/StationIDNumber.js'; +import { SystemCapability } from './src/rpc/structs/SystemCapability.js'; import { TTSChunk } from './src/rpc/structs/TTSChunk.js'; +import { Temperature } from './src/rpc/structs/Temperature.js'; import { TemplateColorScheme } from './src/rpc/structs/TemplateColorScheme.js'; +import { TemplateConfiguration } from './src/rpc/structs/TemplateConfiguration.js'; import { TextField } from './src/rpc/structs/TextField.js'; +import { TireStatus } from './src/rpc/structs/TireStatus.js'; +import { TouchCoord } from './src/rpc/structs/TouchCoord.js'; +import { TouchEvent } from './src/rpc/structs/TouchEvent.js'; import { TouchEventCapabilities } from './src/rpc/structs/TouchEventCapabilities.js'; +import { Turn } from './src/rpc/structs/Turn.js'; +import { VehicleDataResult } from './src/rpc/structs/VehicleDataResult.js'; import { VehicleType } from './src/rpc/structs/VehicleType.js'; import { VideoStreamingCapability } from './src/rpc/structs/VideoStreamingCapability.js'; import { VideoStreamingFormat } from './src/rpc/structs/VideoStreamingFormat.js'; +import { VrHelpItem } from './src/rpc/structs/VrHelpItem.js'; +import { WeatherAlert } from './src/rpc/structs/WeatherAlert.js'; +import { WeatherData } from './src/rpc/structs/WeatherData.js'; +import { WeatherServiceData } from './src/rpc/structs/WeatherServiceData.js'; +import { WeatherServiceManifest } from './src/rpc/structs/WeatherServiceManifest.js'; +import { WindowCapability } from './src/rpc/structs/WindowCapability.js'; +import { WindowTypeCapabilities } from './src/rpc/structs/WindowTypeCapabilities.js'; import { SdlServiceListener } from './src/session/SdlServiceListener.js'; import { SdlSession } from './src/session/SdlSession.js'; import { SdlSessionListener } from './src/session/SdlSessionListener.js'; @@ -180,80 +467,367 @@ const SDL = { RpcResponse, RpcStruct, enums: { + AmbientLightStatus, AppHMIType, + AppInterfaceUnregisteredReason, + AppServiceType, + AudioStreamingIndicator, AudioStreamingState, AudioType, BitsPerSample, + ButtonEventMode, ButtonName, + ButtonPressMode, + CarModeStatus, CharacterSet, + CompassDirection, + ComponentVolumeStatus, + DefrostZone, + DeliveryMode, + DeviceLevelStatus, + Dimension, + Direction, + DisplayMode, DisplayType, + DistanceUnit, + DriverDistractionState, + ECallConfirmationStatus, + ElectronicParkBrakeStatus, + EmergencyEventType, FileType, + FuelCutoffStatus, + FuelType, FunctionID, + GlobalProperty, HMILevel, HmiZoneCapabilities, + HybridAppPreference, + IgnitionStableStatus, + IgnitionStatus, ImageFieldName, ImageType, + InteractionMode, + KeyboardEvent, + KeyboardLayout, + KeypressMode, Language, + LayoutMode, + LightName, + LightStatus, + MaintenanceModeStatus, + MassageCushion, + MassageMode, + MassageZone, MediaClockFormat, + MediaType, + MenuLayout, MetadataType, + ModuleType, + NavigationAction, + NavigationJunction, + PRNDL, + PermissionStatus, + PowerModeQualificationStatus, + PowerModeStatus, + PredefinedLayout, + PredefinedWindows, PrerecordedSpeech, + PrimaryAudioSource, + RadioBand, + RadioState, + RequestType, Result, RpcType, SamplingRate, + SeatMemoryActionType, + ServiceUpdateReason, SoftButtonType, SpeechCapabilities, + SupportedSeat, SystemAction, + SystemCapabilityType, SystemContext, + TBTState, + TPMS, + TemperatureUnit, TextAlignment, TextFieldName, + TimerMode, + TouchType, + TriggerSource, + TurnSignal, + UpdateMode, + VehicleDataActiveStatus, + VehicleDataEventStatus, + VehicleDataNotificationStatus, + VehicleDataResultCode, + VehicleDataStatus, + VehicleDataType, + VentilationMode, VideoStreamingCodec, VideoStreamingProtocol, VideoStreamingState, VrCapabilities, + WarningLightStatus, + WayPointType, + WindowType, + WiperStatus, + messageType, }, messages: { AddCommand, AddCommandResponse, - OnHmiStatus, + AddSubMenu, + AddSubMenuResponse, + Alert, + AlertManeuver, + AlertManeuverResponse, + AlertResponse, + ButtonPress, + ButtonPressResponse, + CancelInteraction, + CancelInteractionResponse, + ChangeRegistration, + ChangeRegistrationResponse, + CloseApplication, + CloseApplicationResponse, + CreateInteractionChoiceSet, + CreateInteractionChoiceSetResponse, + CreateWindow, + CreateWindowResponse, + DeleteCommand, + DeleteCommandResponse, + DeleteFile, + DeleteFileResponse, + DeleteInteractionChoiceSet, + DeleteInteractionChoiceSetResponse, + DeleteSubMenu, + DeleteSubMenuResponse, + DeleteWindow, + DeleteWindowResponse, + DiagnosticMessage, + DiagnosticMessageResponse, + DialNumber, + DialNumberResponse, + EncodedSyncPData, + EncodedSyncPDataResponse, + EndAudioPassThru, + EndAudioPassThruResponse, + GenericResponseResponse, + GetAppServiceData, + GetAppServiceDataResponse, + GetCloudAppProperties, + GetCloudAppPropertiesResponse, + GetDTCs, + GetDTCsResponse, + GetFile, + GetFileResponse, + GetInteriorVehicleData, + GetInteriorVehicleDataConsent, + GetInteriorVehicleDataConsentResponse, + GetInteriorVehicleDataResponse, + GetSystemCapability, + GetSystemCapabilityResponse, + GetVehicleData, + GetVehicleDataResponse, + GetWayPoints, + GetWayPointsResponse, + ListFiles, + ListFilesResponse, + OnAppInterfaceUnregistered, + OnAppServiceData, + OnAudioPassThru, + OnButtonEvent, + OnButtonPress, + OnCommand, + OnDriverDistraction, + OnEncodedSyncPData, + OnHMIStatus, + OnHashChange, + OnInteriorVehicleData, + OnKeyboardInput, OnLanguageChange, + OnPermissionsChange, + OnRCStatus, + OnSystemCapabilityUpdated, + OnSystemRequest, + OnTBTClientState, + OnTouchEvent, + OnVehicleData, + OnWayPointChange, + PerformAppServiceInteraction, + PerformAppServiceInteractionResponse, + PerformAudioPassThru, + PerformAudioPassThruResponse, + PerformInteraction, + PerformInteractionResponse, + PublishAppService, + PublishAppServiceResponse, PutFile, PutFileResponse, + ReadDID, + ReadDIDResponse, RegisterAppInterface, RegisterAppInterfaceResponse, + ReleaseInteriorVehicleDataModule, + ReleaseInteriorVehicleDataModuleResponse, + ResetGlobalProperties, + ResetGlobalPropertiesResponse, + ScrollableMessage, + ScrollableMessageResponse, + SendHapticData, + SendHapticDataResponse, + SendLocation, + SendLocationResponse, SetAppIcon, SetAppIconResponse, + SetCloudAppProperties, + SetCloudAppPropertiesResponse, + SetDisplayLayout, + SetDisplayLayoutResponse, + SetGlobalProperties, + SetGlobalPropertiesResponse, + SetInteriorVehicleData, + SetInteriorVehicleDataResponse, + SetMediaClockTimer, + SetMediaClockTimerResponse, Show, + ShowAppMenu, + ShowAppMenuResponse, + ShowConstantTBT, + ShowConstantTBTResponse, ShowResponse, + Slider, + SliderResponse, + Speak, + SpeakResponse, + SubscribeButton, + SubscribeButtonResponse, + SubscribeVehicleData, + SubscribeVehicleDataResponse, + SubscribeWayPoints, + SubscribeWayPointsResponse, + SystemRequest, + SystemRequestResponse, + UnpublishAppService, + UnpublishAppServiceResponse, UnregisterAppInterface, UnregisterAppInterfaceResponse, + UnsubscribeButton, + UnsubscribeButtonResponse, + UnsubscribeVehicleData, + UnsubscribeVehicleDataResponse, + UnsubscribeWayPoints, + UnsubscribeWayPointsResponse, + UpdateTurnList, + UpdateTurnListResponse, }, structs: { + AirbagStatus, AppInfo, + AppServiceCapability, + AppServiceData, + AppServiceManifest, + AppServiceRecord, + AppServicesCapabilities, + AudioControlCapabilities, + AudioControlData, AudioPassThruCapabilities, + BeltStatus, + BodyInformation, ButtonCapabilities, + Choice, + ClimateControlCapabilities, + ClimateControlData, + CloudAppProperties, + ClusterModeStatus, + Coordinate, + DIDResult, + DateTime, DeviceInfo, + DeviceStatus, DisplayCapabilities, + DisplayCapability, + ECallInfo, + EmergencyEvent, + EqualizerSettings, + FuelRange, + GPSData, Grid, HMICapabilities, + HMIPermissions, + HMISettingsControlCapabilities, + HMISettingsControlData, + HapticRect, + HeadLampStatus, Image, ImageField, ImageResolution, + KeyboardProperties, + LightCapabilities, + LightControlCapabilities, + LightControlData, + LightState, + LocationDetails, + MassageCushionFirmness, + MassageModeData, + MediaServiceData, + MediaServiceManifest, MenuParams, MetadataTags, + ModuleData, ModuleInfo, + MyKey, + NavigationCapability, + NavigationInstruction, + NavigationServiceData, + NavigationServiceManifest, + OASISAddress, + ParameterPermissions, + PermissionItem, + PhoneCapability, PresetBankCapabilities, RGBColor, + RadioControlCapabilities, + RadioControlData, + RdsData, + Rectangle, + RemoteControlCapabilities, ScreenParams, SdlMsgVersion, + SeatControlCapabilities, + SeatControlData, + SeatLocation, + SeatLocationCapability, + SeatMemoryAction, + SingleTireStatus, + SisData, SoftButton, SoftButtonCapabilities, + StartTime, + StationIDNumber, + SystemCapability, TTSChunk, + Temperature, TemplateColorScheme, + TemplateConfiguration, TextField, + TireStatus, + TouchCoord, + TouchEvent, TouchEventCapabilities, + Turn, + VehicleDataResult, VehicleType, VideoStreamingCapability, VideoStreamingFormat, + VrHelpItem, + WeatherAlert, + WeatherData, + WeatherServiceData, + WeatherServiceManifest, + WindowCapability, + WindowTypeCapabilities, }, }, session: { diff --git a/lib/js/dist/SDL.js b/lib/js/dist/SDL.js index 9401f8fe..2a6c4262 100644 --- a/lib/js/dist/SDL.js +++ b/lib/js/dist/SDL.js @@ -1,2 +1,2 @@ -!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e=e||self).SDL=t()}(this,function(){"use strict";function _typeof(e){return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _defineProperties(e,t){for(var n=0;n=n())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+n().toString(16)+" bytes");return 0|e}function h(e,t){if(_.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return w(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return F(e).length;default:if(r)return w(e).length;t=(""+t).toLowerCase(),r=!0}}function E(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function p(e,t,n,r,i){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):2147483647=e.length){if(i)return-1;n=e.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof t&&(t=_.from(t,r)),_.isBuffer(t))return 0===t.length?-1:y(e,t,n,r,i);if("number"==typeof t)return t&=255,_.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):y(e,[t],n,r,i);throw new TypeError("val must be string, number or Buffer")}function y(e,t,n,r,i){var o,s=1,a=e.length,u=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;a/=s=2,u/=2,n/=2}function l(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(i){var c=-1;for(o=n;o>8,i=n%256,o.push(i),o.push(r);return o}(t,e.length-n),e,n,r)}function d(e,t,n){return 0===t&&n===e.length?r.fromByteArray(e):r.fromByteArray(e.slice(t,n))}function T(e,t,n){n=Math.min(e.length,n);for(var r=[],i=t;i>>10&1023|55296),c=56320|1023&c),r.push(c),i+=_}return function(e){var t=e.length;if(t<=P)return String.fromCharCode.apply(String,e);var n="",r=0;for(;rthis.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(t>>>=0))return"";for(e=e||"utf8";;)switch(e){case"hex":return m(this,t,n);case"utf8":case"utf-8":return T(this,t,n);case"ascii":return v(this,t,n);case"latin1":case"binary":return I(this,t,n);case"base64":return d(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return O(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}.apply(this,arguments)},_.prototype.equals=function(e){if(!_.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===_.compare(this,e)},_.prototype.inspect=function(){var e="",t=U.INSPECT_MAX_BYTES;return 0t&&(e+=" ... ")),""},_.prototype.compare=function(e,t,n,r,i){if(!_.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),t<0||n>e.length||r<0||i>this.length)throw new RangeError("out of range index");if(i<=r&&n<=t)return 0;if(i<=r)return-1;if(n<=t)return 1;if(this===e)return 0;for(var o=(i>>>=0)-(r>>>=0),s=(n>>>=0)-(t>>>=0),a=Math.min(o,s),u=this.slice(r,i),l=e.slice(t,n),c=0;cthis.length)throw new RangeError("Attempt to write outside buffer bounds");r=r||"utf8";for(var o,s,a,u,l,c,_=!1;;)switch(r){case"hex":return g(this,e,t,n);case"utf8":case"utf-8":return l=t,c=n,Y(w(e,(u=this).length-l),u,l,c);case"ascii":return A(this,e,t,n);case"latin1":case"binary":return A(this,e,t,n);case"base64":return o=this,s=t,a=n,Y(F(e),o,s,a);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return S(this,e,t,n);default:if(_)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),_=!0}},_.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var P=4096;function v(e,t,n){var r="";n=Math.min(e.length,n);for(var i=t;ie.length)throw new RangeError("Index out of range")}function N(e,t,n,r){t<0&&(t=65535+t+1);for(var i=0,o=Math.min(e.length-n,2);i>>8*(r?i:1-i)}function b(e,t,n,r){t<0&&(t=4294967295+t+1);for(var i=0,o=Math.min(e.length-n,4);i>>8*(r?i:3-i)&255}function k(e,t,n,r){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function M(e,t,n,r,i){return i||k(e,0,n,4),o.write(e,t,n,r,23,4),n+4}function D(e,t,n,r,i){return i||k(e,0,n,8),o.write(e,t,n,r,52,8),n+8}_.prototype.slice=function(e,t){var n,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):r>>8):N(this,e,t,!0),t+2},_.prototype.writeUInt16BE=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,2,65535,0),_.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):N(this,e,t,!1),t+2},_.prototype.writeUInt32LE=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,4,4294967295,0),_.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):b(this,e,t,!0),t+4},_.prototype.writeUInt32BE=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,4,4294967295,0),_.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):b(this,e,t,!1),t+4},_.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);R(this,e,t,n,i-1,-i)}var o=0,s=1,a=0;for(this[t]=255&e;++o>0)-a&255;return t+n},_.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);R(this,e,t,n,i-1,-i)}var o=n-1,s=1,a=0;for(this[t+o]=255&e;0<=--o&&(s*=256);)e<0&&0===a&&0!==this[t+o+1]&&(a=1),this[t+o]=(e/s>>0)-a&255;return t+n},_.prototype.writeInt8=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,1,127,-128),_.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},_.prototype.writeInt16LE=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,2,32767,-32768),_.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):N(this,e,t,!0),t+2},_.prototype.writeInt16BE=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,2,32767,-32768),_.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):N(this,e,t,!1),t+2},_.prototype.writeInt32LE=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,4,2147483647,-2147483648),_.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):b(this,e,t,!0),t+4},_.prototype.writeInt32BE=function(e,t,n){return e=+e,t|=0,n||R(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),_.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):b(this,e,t,!1),t+4},_.prototype.writeFloatLE=function(e,t,n){return M(this,e,t,!0,n)},_.prototype.writeFloatBE=function(e,t,n){return M(this,e,t,!1,n)},_.prototype.writeDoubleLE=function(e,t,n){return D(this,e,t,!0,n)},_.prototype.writeDoubleBE=function(e,t,n){return D(this,e,t,!1,n)},_.prototype.copy=function(e,t,n,r){if(n=n||0,r||0===r||(r=this.length),t>=e.length&&(t=e.length),t=t||0,0=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t>>=0,n=void 0===n?this.length:n>>>0,"number"==typeof(e=e||0))for(o=t;o>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;o.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return o}function F(e){return r.toByteArray(B(e))}function Y(e,t,n,r){for(var i=0;i=t.length||i>=e.length);++i)t[i+n]=e[i];return i}}).call(U,K(0))},function(module,exports,__webpack_require__){(function(global,Buffer){var _t;_t=function(exports,_long,buffer){_long=_long&&_long.hasOwnProperty("default")?_long.default:_long,buffer=buffer&&buffer.hasOwnProperty("default")?buffer.default:buffer;var commonjsGlobal="undefined"!=typeof window?window:void 0!==global?global:"undefined"!=typeof self?self:{};function createCommonjsModule(e,t){return e(t={exports:{}},t.exports),t.exports}function getCjsExportFromNamespace(e){return e&&e.default||e}var map=createCommonjsModule(function(e){if(void 0!==commonjsGlobal.Map)e.exports=commonjsGlobal.Map,e.exports.Map=commonjsGlobal.Map;else{var t=function(e){this._keys=[],this._values={};for(var t=0;t>8&255,n[1]=e>>16&255,n[0]=e>>24&255,n[4]=PROCESS_UNIQUE[0],n[5]=PROCESS_UNIQUE[1],n[6]=PROCESS_UNIQUE[2],n[7]=PROCESS_UNIQUE[3],n[8]=PROCESS_UNIQUE[4],n[11]=255&t,n[10]=t>>8&255,n[9]=t>>16&255,n}},{key:"createPk",value:function(){return new i}},{key:"createFromTime",value:function(e){var t=Buffer$1.from([0,0,0,0,0,0,0,0,0,0,0,0]);return t[3]=255&e,t[2]=e>>8&255,t[1]=e>>16&255,t[0]=e>>24&255,new i(t)}},{key:"createFromHexString",value:function(e){if(void 0===e||null!=e&&24!==e.length)throw new TypeError("Argument passed in must be a single String of 12 bytes or a string of 24 hex characters");if(hasBufferType)return new i(Buffer$1.from(e,"hex"));for(var t=new _Buffer(12),n=0,r=0;r<24;)t[n++]=decodeLookup[e.charCodeAt(r++)]<<4|decodeLookup[e.charCodeAt(r++)];return new i(t)}},{key:"isValid",value:function(e){return null!=e&&("number"==typeof e||("string"==typeof e?12===e.length||24===e.length&&checkForHexRegExp.test(e):e instanceof i||(e instanceof _Buffer&&12===e.length||!!e.toHexString&&(12===e.id.length||24===e.id.length&&checkForHexRegExp.test(e.id)))))}},{key:"fromExtendedJSON",value:function(e){return new i(e.$oid)}}]),i}();ObjectId.get_inc=deprecate$1(function(){return ObjectId.getInc()},"Please use the static `ObjectId.getInc()` instead"),ObjectId.prototype.get_inc=deprecate$1(function(){return ObjectId.getInc()},"Please use the static `ObjectId.getInc()` instead"),ObjectId.prototype.getInc=deprecate$1(function(){return ObjectId.getInc()},"Please use the static `ObjectId.getInc()` instead"),ObjectId.prototype.generate=deprecate$1(function(e){return ObjectId.generate(e)},"Please use the static `ObjectId.generate(time)` instead"),Object.defineProperty(ObjectId.prototype,"generationTime",{enumerable:!0,get:function(){return this.id[3]|this.id[2]<<8|this.id[1]<<16|this.id[0]<<24},set:function(e){this.id[3]=255&e,this.id[2]=e>>8&255,this.id[1]=e>>16&255,this.id[0]=e>>24&255}}),ObjectId.prototype[util$2.inspect.custom||"inspect"]=ObjectId.prototype.toString,ObjectId.index=~~(16777215*Math.random()),Object.defineProperty(ObjectId.prototype,"_bsontype",{value:"ObjectID"});var objectid=ObjectId;function _classCallCheck$3(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _defineProperties$3(e,t){for(var n=0;n>>0,r=t.high>>>0;return n>>0>>0}function invalidErr(e,t){throw new TypeError('"'.concat(e,'" is not a valid Decimal128 string - ').concat(t))}function Decimal128(e){this.bytes=e}Decimal128.fromString=function(e){var t,n=!1,r=!1,i=!1,o=0,s=0,a=0,u=0,l=0,c=[0],_=0,f=0,h=0,E=0,p=0,y=0,g=[0,0],A=[0,0],S=0;if(7e3<=e.length)throw new TypeError(e+" not a valid Decimal128 string");var d=e.match(PARSE_STRING_REGEXP),T=e.match(PARSE_INF_REGEXP),P=e.match(PARSE_NAN_REGEXP);if(!d&&!T&&!P||0===e.length)throw new TypeError(e+" not a valid Decimal128 string");if(d){var v=d[2],I=d[4],m=d[5],O=d[6];I&&void 0===O&&invalidErr(e,"missing exponent power"),I&&void 0===v&&invalidErr(e,"missing exponent base"),void 0===I&&(m||O)&&invalidErr(e,"missing e before exponent")}if("+"!==e[S]&&"-"!==e[S]||(n="-"===e[S++]),!isDigit(e[S])&&"."!==e[S]){if("i"===e[S]||"I"===e[S])return new Decimal128(Buffer$2.from(n?INF_NEGATIVE_BUFFER:INF_POSITIVE_BUFFER));if("N"===e[S])return new Decimal128(Buffer$2.from(NAN_BUFFER))}for(;isDigit(e[S])||"."===e[S];)"."!==e[S]?(_<34&&("0"===e[S]&&!i||(i||(l=s),i=!0,c[f++]=parseInt(e[S],10),_+=1)),i&&(a+=1),r&&(u+=1),s+=1):(r&&invalidErr(e,"contains multiple periods"),r=!0),S+=1;if(r&&!s)throw new TypeError(e+" not a valid Decimal128 string");if("e"===e[S]||"E"===e[S]){var C=e.substr(++S).match(EXPONENT_REGEX);if(!C||!C[2])return new Decimal128(Buffer$2.from(NAN_BUFFER));p=parseInt(C[0],10),S+=C[0].length}if(e[S])return new Decimal128(Buffer$2.from(NAN_BUFFER));if(h=0,_){if(E=_-1,1!==(o=a))for(;"0"===e[l+o-1];)o-=1}else _=a=1,o=c[E=h=0]=0;for(p<=u&&16384>8&255,w[S++]=L.low.low>>16&255,w[S++]=L.low.low>>24&255,w[S++]=255&L.low.high,w[S++]=L.low.high>>8&255,w[S++]=L.low.high>>16&255,w[S++]=L.low.high>>24&255,w[S++]=255&L.high.low,w[S++]=L.high.low>>8&255,w[S++]=L.high.low>>16&255,w[S++]=L.high.low>>24&255,w[S++]=255&L.high.high,w[S++]=L.high.high>>8&255,w[S++]=L.high.high>>16&255,w[S++]=L.high.high>>24&255,new Decimal128(w)};var COMBINATION_MASK=31,EXPONENT_MASK=16383,COMBINATION_INFINITY=30,COMBINATION_NAN=31;Decimal128.prototype.toString=function(){for(var e,t,n,r,i,o,s=0,a=new Array(36),u=0;u>26&COMBINATION_MASK)>>3==3){if(i===COMBINATION_INFINITY)return g.join("")+"Infinity";if(i===COMBINATION_NAN)return"NaN";o=e>>15&EXPONENT_MASK,_=8+(e>>14&1)}else _=e>>14&7,o=e>>17&EXPONENT_MASK;if(l=o-EXPONENT_BIAS,y.parts[0]=(16383&e)+((15&_)<<14),y.parts[1]=t,y.parts[2]=n,y.parts[3]=r,0===y.parts[0]&&0===y.parts[1]&&0===y.parts[2]&&0===y.parts[3])p=!0;else for(h=3;0<=h;h--){var S=0,d=divideu128(y);if(y=d.quotient,S=d.rem.low)for(f=8;0<=f;f--)a[9*h+f]=S%10,S=Math.floor(S/10)}if(p)s=1,a[E]=0;else for(s=36;!a[E];)s-=1,E+=1;if(34<=(c=s-1+l)||c<=-7||0this.position)this.buffer[this.position++]=t;else if(void 0!==Buffer$3&&Buffer$3.isBuffer(this.buffer)){var n=Buffer$3.alloc(o.BUFFER_SIZE+this.buffer.length);this.buffer.copy(n,0,0,this.buffer.length),this.buffer=n,this.buffer[this.position++]=t}else{var r=null;r=isUint8Array(this.buffer)?new Uint8Array(new ArrayBuffer(o.BUFFER_SIZE+this.buffer.length)):new Array(o.BUFFER_SIZE+this.buffer.length);for(var i=0;ithis.position?t+e.length:this.position;else if(void 0!==Buffer$3&&"string"==typeof e&&Buffer$3.isBuffer(this.buffer))this.buffer.write(e,t,"binary"),this.position=t+e.length>this.position?t+e.length:this.position;else if(isUint8Array(e)||Array.isArray(e)&&"string"!=typeof e){for(var i=0;ithis.position?t:this.position}else if("string"==typeof e){for(var o=0;othis.position?t:this.position}}},{key:"read",value:function(e,t){if(t=t&&0= 5, is ".concat(i));if(t.allowObjectSmallerThanBufferSize&&e.length= bson size ").concat(i));if(!t.allowObjectSmallerThanBufferSize&&e.length!==i)throw new Error("buffer length ".concat(e.length," must === bson size ").concat(i));if(i+r>e.length)throw new Error("(bson size ".concat(i," + options.index ").concat(r," must be <= buffer length ").concat(Buffer$4.byteLength(e),")"));if(0!==e[r+i-1])throw new Error("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");return deserializeObject(e,r,t,n)}function deserializeObject(e,t,n,r){var i=null!=n.evalFunctions&&n.evalFunctions,o=null!=n.cacheFunctions&&n.cacheFunctions,s=null!=n.cacheFunctionsCrc32&&n.cacheFunctionsCrc32;if(!s)var a=null;var u=null==n.fieldsAsRaw?null:n.fieldsAsRaw,l=null!=n.raw&&n.raw,c="boolean"==typeof n.bsonRegExp&&n.bsonRegExp,_=null!=n.promoteBuffers&&n.promoteBuffers,f=null==n.promoteLongs||n.promoteLongs,h=null==n.promoteValues||n.promoteValues,E=t;if(e.length<5)throw new Error("corrupt bson message < 5 bytes long");var p=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(p<5||p>e.length)throw new Error("corrupt bson message");for(var y=r?[]:{},g=0;;){var A=e[t++];if(0===A)break;for(var S=t;0!==e[S]&&S=Buffer$4.byteLength(e))throw new Error("Bad BSON Document: illegal CString");var d=r?g++:e.toString("utf8",t,S);if(t=S+1,A===constants.BSON_DATA_STRING){var T=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(T<=0||T>e.length-t||0!==e[t+T-1])throw new Error("bad string length in bson");if(!validateUtf8$1(e,t,t+T-1))throw new Error("Invalid UTF-8 string in BSON document");var P=e.toString("utf8",t,t+T-1);y[d]=P,t+=T}else if(A===constants.BSON_DATA_OID){var v=Buffer$4.alloc(12);e.copy(v,0,t,t+12),y[d]=new objectid(v),t+=12}else if(A===constants.BSON_DATA_INT&&!1===h)y[d]=new int_32(e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24);else if(A===constants.BSON_DATA_INT)y[d]=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;else if(A===constants.BSON_DATA_NUMBER&&!1===h)y[d]=new double_1(e.readDoubleLE(t)),t+=8;else if(A===constants.BSON_DATA_NUMBER)y[d]=e.readDoubleLE(t),t+=8;else if(A===constants.BSON_DATA_DATE){var I=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,m=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;y[d]=new Date(new long_1(I,m).toNumber())}else if(A===constants.BSON_DATA_BOOLEAN){if(0!==e[t]&&1!==e[t])throw new Error("illegal boolean type value");y[d]=1===e[t++]}else if(A===constants.BSON_DATA_OBJECT){var O=t,C=e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24;if(C<=0||C>e.length-t)throw new Error("bad embedded document length in bson");y[d]=l?e.slice(t,t+C):deserializeObject(e,O,n,!1),t+=C}else if(A===constants.BSON_DATA_ARRAY){var R=t,N=e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24,b=n,k=t+N;if(u&&u[d]){for(var M in b={},n)b[M]=n[M];b.raw=!0}if(y[d]=deserializeObject(e,R,b,!0),0!==e[(t+=N)-1])throw new Error("invalid array terminator byte");if(t!==k)throw new Error("corrupted array bson")}else if(A===constants.BSON_DATA_UNDEFINED)y[d]=void 0;else if(A===constants.BSON_DATA_NULL)y[d]=null;else if(A===constants.BSON_DATA_LONG){var D=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,B=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,L=new long_1(D,B);y[d]=f&&!0===h&&L.lessThanOrEqual(JS_INT_MAX_LONG)&&L.greaterThanOrEqual(JS_INT_MIN_LONG)?L.toNumber():L}else if(A===constants.BSON_DATA_DECIMAL128){var w=Buffer$4.alloc(16);e.copy(w,0,t,t+16),t+=16;var F=new decimal128(w);y[d]=F.toObject?F.toObject():F}else if(A===constants.BSON_DATA_BINARY){var Y=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,U=Y,K=e[t++];if(Y<0)throw new Error("Negative binary type element size found");if(Y>Buffer$4.byteLength(e))throw new Error("Binary type size larger than document size");if(null!=e.slice){if(K===binary.SUBTYPE_BYTE_ARRAY){if((Y=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24)<0)throw new Error("Negative binary type element size found for subtype 0x02");if(U-4=e.length)throw new Error("Bad BSON Document: illegal CString");var H=e.toString("utf8",t,S);for(S=t=S+1;0!==e[S]&&S=e.length)throw new Error("Bad BSON Document: illegal CString");var x=e.toString("utf8",t,S);t=S+1;var G=new Array(x.length);for(S=0;S=e.length)throw new Error("Bad BSON Document: illegal CString");var j=e.toString("utf8",t,S);for(S=t=S+1;0!==e[S]&&S=e.length)throw new Error("Bad BSON Document: illegal CString");var $=e.toString("utf8",t,S);t=S+1,y[d]=new regexp(j,$)}else if(A===constants.BSON_DATA_SYMBOL){var z=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(z<=0||z>e.length-t||0!==e[t+z-1])throw new Error("bad string length in bson");y[d]=e.toString("utf8",t,t+z-1),t+=z}else if(A===constants.BSON_DATA_TIMESTAMP){var W=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,X=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;y[d]=new timestamp(W,X)}else if(A===constants.BSON_DATA_MIN_KEY)y[d]=new min_key;else if(A===constants.BSON_DATA_MAX_KEY)y[d]=new max_key;else if(A===constants.BSON_DATA_CODE){var J=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(J<=0||J>e.length-t||0!==e[t+J-1])throw new Error("bad string length in bson");var Z=e.toString("utf8",t,t+J-1);if(i)if(o){var q=s?a(Z):Z;y[d]=isolateEvalWithHash(functionCache,q,Z,y)}else y[d]=isolateEval(Z);else y[d]=new code(Z);t+=J}else if(A===constants.BSON_DATA_CODE_W_SCOPE){var Q=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(Q<13)throw new Error("code_w_scope total size shorter minimum expected length");var ee=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(ee<=0||ee>e.length-t||0!==e[t+ee-1])throw new Error("bad string length in bson");var te=e.toString("utf8",t,t+ee-1),ne=t+=ee,re=e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24,ie=deserializeObject(e,ne,n,!1);if(t+=re,Q<8+re+ee)throw new Error("code_w_scope total size is to short, truncating scope");if(8+re+eee.length-t||0!==e[t+se-1])throw new Error("bad string length in bson");if(!validateUtf8$1(e,t,t+se-1))throw new Error("Invalid UTF-8 string in BSON document");var ae=e.toString("utf8",t,t+se-1);t+=se;var ue=Buffer$4.alloc(12);e.copy(ue,0,t,t+12);var le=new objectid(ue);t+=12,y[d]=new db_ref(ae,le)}}if(p!=t-E){if(r)throw new Error("corrupt array bson");throw new Error("corrupt object bson")}var ce=Object.keys(y).filter(function(e){return e.startsWith("$")}),_e=!0;if(ce.forEach(function(e){-1===["$ref","$id","$db"].indexOf(e)&&(_e=!1)}),!_e)return y;if(null==y.$id||null==y.$ref)return y;var fe=Object.assign({},y);return delete fe.$ref,delete fe.$id,delete fe.$db,new db_ref(y.$ref,y.$id,y.$db||null,fe)}function isolateEvalWithHash(functionCache,hash,functionString,object){var value=null;return null==functionCache[hash]&&(eval("value = "+functionString),functionCache[hash]=value),functionCache[hash].bind(object)}function isolateEval(functionString){var value=null;return eval("value = "+functionString),value}var deserializer=deserialize$1;function readIEEE754(e,t,n,r,i){var o,s,a="big"===n,u=8*i-r-1,l=(1<>1,_=-7,f=a?0:i-1,h=a?1:-1,E=e[t+f];for(f+=h,o=E&(1<<-_)-1,E>>=-_,_+=u;0<_;o=256*o+e[t+f],f+=h,_-=8);for(s=o&(1<<-_)-1,o>>=-_,_+=r;0<_;s=256*s+e[t+f],f+=h,_-=8);if(0===o)o=1-c;else{if(o===l)return s?NaN:1/0*(E?-1:1);s+=Math.pow(2,r),o-=c}return(E?-1:1)*s*Math.pow(2,o-r)}function writeIEEE754(e,t,n,r,i,o){var s,a,u,l="big"===r,c=8*o-i-1,_=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,E=l?o-1:0,p=l?-1:1,y=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=_):(s=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-s))<1&&(s--,u*=2),2<=(t+=1<=s+f?h/u:h*Math.pow(2,1-f))*u&&(s++,u/=2),_<=s+f?(a=0,s=_):1<=s+f?(a=(t*u-1)*Math.pow(2,i),s+=f):(a=t*Math.pow(2,f-1)*Math.pow(2,i),s=0)),isNaN(t)&&(a=0);8<=i;)e[n+E]=255&a,E+=p,a/=256,i-=8;for(s=s<>24&255,e[r+2]=s+1>>16&255,e[r+1]=s+1>>8&255,e[r]=s+1&255,r=r+4+s,e[r++]=0,r}function serializeNumber(e,t,n,r,i){if(Math.floor(n)===n&&n>=constants.JS_INT_MIN&&n<=constants.JS_INT_MAX)if(n>=constants.BSON_INT32_MIN&&n<=constants.BSON_INT32_MAX)e[r++]=constants.BSON_DATA_INT,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,e[r++]=255&n,e[r++]=n>>8&255,e[r++]=n>>16&255,e[r++]=n>>24&255;else if(n>=constants.JS_INT_MIN&&n<=constants.JS_INT_MAX){e[r++]=constants.BSON_DATA_NUMBER,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,writeIEEE754$1(e,n,r,"little",52,8),r+=8}else{e[r++]=constants.BSON_DATA_LONG,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var o=long_1.fromNumber(n),s=o.getLowBits(),a=o.getHighBits();e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,e[r++]=255&a,e[r++]=a>>8&255,e[r++]=a>>16&255,e[r++]=a>>24&255}else e[r++]=constants.BSON_DATA_NUMBER,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,writeIEEE754$1(e,n,r,"little",52,8),r+=8;return r}function serializeNull(e,t,n,r,i){return e[r++]=constants.BSON_DATA_NULL,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,r}function serializeBoolean(e,t,n,r,i){return e[r++]=constants.BSON_DATA_BOOLEAN,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,e[r++]=n?1:0,r}function serializeDate(e,t,n,r,i){e[r++]=constants.BSON_DATA_DATE,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var o=long_1.fromNumber(n.getTime()),s=o.getLowBits(),a=o.getHighBits();return e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,e[r++]=255&a,e[r++]=a>>8&255,e[r++]=a>>16&255,e[r++]=a>>24&255,r}function serializeRegExp(e,t,n,r,i){if(e[r++]=constants.BSON_DATA_REGEXP,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,n.source&&null!=n.source.match(regexp$1))throw Error("value "+n.source+" must not contain null bytes");return r+=e.write(n.source,r,"utf8"),e[r++]=0,n.ignoreCase&&(e[r++]=105),n.global&&(e[r++]=115),n.multiline&&(e[r++]=109),e[r++]=0,r}function serializeBSONRegExp(e,t,n,r,i){if(e[r++]=constants.BSON_DATA_REGEXP,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,null!=n.pattern.match(regexp$1))throw Error("pattern "+n.pattern+" must not contain null bytes");return r+=e.write(n.pattern,r,"utf8"),e[r++]=0,r+=e.write(n.options.split("").sort().join(""),r,"utf8"),e[r++]=0,r}function serializeMinMax(e,t,n,r,i){return null===n?e[r++]=constants.BSON_DATA_NULL:"MinKey"===n._bsontype?e[r++]=constants.BSON_DATA_MIN_KEY:e[r++]=constants.BSON_DATA_MAX_KEY,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,r}function serializeObjectId(e,t,n,r,i){if(e[r++]=constants.BSON_DATA_OID,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,"string"==typeof n.id)e.write(n.id,r,"binary");else{if(!n.id||!n.id.copy)throw new TypeError("object ["+JSON.stringify(n)+"] is not a valid ObjectId");n.id.copy(e,r,0,12)}return r+12}function serializeBuffer(e,t,n,r,i){e[r++]=constants.BSON_DATA_BINARY,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var o=n.length;return e[r++]=255&o,e[r++]=o>>8&255,e[r++]=o>>16&255,e[r++]=o>>24&255,e[r++]=constants.BSON_BINARY_SUBTYPE_DEFAULT,n.copy(e,r,0,o),r+=o}function serializeObject(e,t,n,r,i,o,s,a,u,l){for(var c=0;c>8&255,e[r++]=o>>16&255,e[r++]=o>>24&255,e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,r}function serializeInt32(e,t,n,r,i){return e[r++]=constants.BSON_DATA_INT,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,e[r++]=255&n,e[r++]=n>>8&255,e[r++]=n>>16&255,e[r++]=n>>24&255,r}function serializeDouble(e,t,n,r,i){return e[r++]=constants.BSON_DATA_NUMBER,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,writeIEEE754$1(e,n.value,r,"little",52,8),r+=8}function serializeFunction(e,t,n,r,i,o,s){e[r++]=constants.BSON_DATA_CODE,r+=s?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a=normalizedFunctionString$1(n),u=e.write(a,r+4,"utf8")+1;return e[r]=255&u,e[r+1]=u>>8&255,e[r+2]=u>>16&255,e[r+3]=u>>24&255,r=r+4+u-1,e[r++]=0,r}function serializeCode(e,t,n,r,i,o,s,a,u){if(n.scope&&"object"===_typeof$3(n.scope)){e[r++]=constants.BSON_DATA_CODE_W_SCOPE,r+=u?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var l=r,c="string"==typeof n.code?n.code:n.code.toString();r+=4;var _=e.write(c,r+4,"utf8")+1;e[r]=255&_,e[r+1]=_>>8&255,e[r+2]=_>>16&255,e[r+3]=_>>24&255,e[r+4+_-1]=0,r=r+_+4;var f=serializeInto(e,n.scope,i,r,o+1,s,a);r=f-1;var h=f-l;e[l++]=255&h,e[l++]=h>>8&255,e[l++]=h>>16&255,e[l++]=h>>24&255,e[r++]=0}else{e[r++]=constants.BSON_DATA_CODE,r+=u?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var E=n.code.toString(),p=e.write(E,r+4,"utf8")+1;e[r]=255&p,e[r+1]=p>>8&255,e[r+2]=p>>16&255,e[r+3]=p>>24&255,r=r+4+p-1,e[r++]=0}return r}function serializeBinary(e,t,n,r,i){e[r++]=constants.BSON_DATA_BINARY,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var o=n.value(!0),s=n.position;return n.sub_type===binary.SUBTYPE_BYTE_ARRAY&&(s+=4),e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,e[r++]=n.sub_type,n.sub_type===binary.SUBTYPE_BYTE_ARRAY&&(s-=4,e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255),o.copy(e,r,0,n.position),r+=n.position}function serializeSymbol(e,t,n,r,i){e[r++]=constants.BSON_DATA_SYMBOL,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var o=e.write(n.value,r+4,"utf8")+1;return e[r]=255&o,e[r+1]=o>>8&255,e[r+2]=o>>16&255,e[r+3]=o>>24&255,r=r+4+o-1,e[r++]=0,r}function serializeDBRef(e,t,n,r,i,o,s){e[r++]=constants.BSON_DATA_OBJECT,r+=s?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a,u=r,l={$ref:n.collection||n.namespace,$id:n.oid};null!=n.db&&(l.$db=n.db);var c=(a=serializeInto(e,l=Object.assign(l,n.fields),!1,r,i+1,o))-u;return e[u++]=255&c,e[u++]=c>>8&255,e[u++]=c>>16&255,e[u++]=c>>24&255,a}function serializeInto(e,t,n,r,i,o,s,a){r=r||0,(a=a||[]).push(t);var u=r+4;if(Array.isArray(t))for(var l=0;l>8&255,e[r++]=P>>16&255,e[r++]=P>>24&255,u}var serializer=serializeInto;function _typeof$4(e){return(_typeof$4="function"==typeof Symbol&&"symbol"===_typeof(Symbol.iterator)?function(e){return _typeof(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":_typeof(e)})(e)}var Buffer$6=buffer.Buffer,normalizedFunctionString$2=utils.normalizedFunctionString;function isDate$2(e){return"object"===_typeof$4(e)&&"[object Date]"===Object.prototype.toString.call(e)}function calculateObjectSize(e,t,n){var r=5;if(Array.isArray(e))for(var i=0;i=constants.JS_INT_MIN&&t<=constants.JS_INT_MAX&&t>=constants.BSON_INT32_MIN&&t<=constants.BSON_INT32_MAX?(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+5:(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+9;case"undefined":return r||!i?(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+1:0;case"boolean":return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+2;case"object":if(null==t||"MinKey"===t._bsontype||"MaxKey"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+1;if("ObjectId"===t._bsontype||"ObjectID"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+13;if(t instanceof Date||isDate$2(t))return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+9;if(void 0!==Buffer$6&&Buffer$6.isBuffer(t))return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+6+t.length;if("Long"===t._bsontype||"Double"===t._bsontype||"Timestamp"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+9;if("Decimal128"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+17;if("Code"===t._bsontype)return null!=t.scope&&0>16&255,s[a++]=t>>8&255,s[a++]=255&t;2===o&&(t=l[e.charCodeAt(n)]<<2|l[e.charCodeAt(n+1)]>>4,s[a++]=255&t);1===o&&(t=l[e.charCodeAt(n)]<<10|l[e.charCodeAt(n+1)]<<4|l[e.charCodeAt(n+2)]>>2,s[a++]=t>>8&255,s[a++]=255&t);return s},t.fromByteArray=function(e){for(var t,n=e.length,r=n%3,i=[],o=0,s=n-r;o>2]+a[t<<4&63]+"==")):2==r&&(t=(e[n-2]<<8)+e[n-1],i.push(a[t>>10]+a[t>>4&63]+a[t<<2&63]+"="));return i.join("")};for(var a=[],l=[],c="undefined"!=typeof Uint8Array?Uint8Array:Array,r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,o=r.length;i>18&63]+a[i>>12&63]+a[i>>6&63]+a[63&i]);return o.join("")}l["-".charCodeAt(0)]=62,l["_".charCodeAt(0)]=63},function(e,t){t.read=function(e,t,n,r,i){var o,s,a=8*i-r-1,u=(1<>1,c=-7,_=n?i-1:0,f=n?-1:1,h=e[t+_];for(_+=f,o=h&(1<<-c)-1,h>>=-c,c+=a;0>=-c,c+=r;0>1,f=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:o-1,E=r?1:-1,p=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-s))<1&&(s--,u*=2),2<=(t+=1<=s+_?f/u:f*Math.pow(2,1-_))*u&&(s++,u/=2),c<=s+_?(a=0,s=c):1<=s+_?(a=(t*u-1)*Math.pow(2,i),s+=_):(a=t*Math.pow(2,_-1)*Math.pow(2,i),s=0));8<=i;e[n+h]=255&a,h+=E,a/=256,i-=8);for(s=s<>>=0)&&e<256)&&(r=s[e])?r:(n=y(e,(0|e)<0?-1:0,!0),i&&(s[e]=n),n):(i=-128<=(e|=0)&&e<128)&&(r=o[e])?r:(n=y(e,e<0?-1:0,!1),i&&(o[e]=n),n)}function p(e,t){if(isNaN(e))return t?l:S;if(t){if(e<0)return l;if(a<=e)return v}else{if(e<=-u)return I;if(u<=e+1)return P}return e<0?p(-e,t).neg():y(e%i|0,e/i|0,t)}function y(e,t,n){return new r(e,t,n)}r.fromInt=n,r.fromNumber=p,r.fromBits=y;var c=Math.pow;function _(e,t,n){if(0===e.length)throw Error("empty string");if("NaN"===e||"Infinity"===e||"+Infinity"===e||"-Infinity"===e)return S;if(t="number"==typeof t?(n=t,!1):!!t,(n=n||10)<2||36>>0:this.low},m.toNumber=function(){return this.unsigned?(this.high>>>0)*i+(this.low>>>0):this.high*i+(this.low>>>0)},m.toString=function(e){if((e=e||10)<2||36>>0).toString(e);if((o=a).isZero())return u+s;for(;u.length<6;)u="0"+u;s=""+u+s}},m.getHighBits=function(){return this.high},m.getHighBitsUnsigned=function(){return this.high>>>0},m.getLowBits=function(){return this.low},m.getLowBitsUnsigned=function(){return this.low>>>0},m.getNumBitsAbs=function(){if(this.isNegative())return this.eq(I)?64:this.neg().getNumBitsAbs();for(var e=0!=this.high?this.high:this.low,t=31;0>>31!=1||e.high>>>31!=1)&&(this.high===e.high&&this.low===e.low)},m.eq=m.equals,m.notEquals=function(e){return!this.eq(e)},m.neq=m.notEquals,m.ne=m.notEquals,m.lessThan=function(e){return this.comp(e)<0},m.lt=m.lessThan,m.lessThanOrEqual=function(e){return this.comp(e)<=0},m.lte=m.lessThanOrEqual,m.le=m.lessThanOrEqual,m.greaterThan=function(e){return 0>>0>this.high>>>0||e.high===this.high&&e.low>>>0>this.low>>>0?-1:1:this.sub(e).isNegative()?-1:1},m.comp=m.compare,m.negate=function(){return!this.unsigned&&this.eq(I)?I:this.not().add(f)},m.neg=m.negate,m.add=function(e){E(e)||(e=g(e));var t=this.high>>>16,n=65535&this.high,r=this.low>>>16,i=65535&this.low,o=e.high>>>16,s=65535&e.high,a=e.low>>>16,u=0,l=0,c=0,_=0;return c+=(_+=i+(65535&e.low))>>>16,l+=(c+=r+a)>>>16,u+=(l+=n+s)>>>16,u+=t+o,y((c&=65535)<<16|(_&=65535),(u&=65535)<<16|(l&=65535),this.unsigned)},m.subtract=function(e){return E(e)||(e=g(e)),this.add(e.neg())},m.sub=m.subtract,m.multiply=function(e){if(this.isZero())return S;if(E(e)||(e=g(e)),h)return y(h.mul(this.low,this.high,e.low,e.high),h.get_high(),this.unsigned);if(e.isZero())return S;if(this.eq(I))return e.isOdd()?I:S;if(e.eq(I))return this.isOdd()?I:S;if(this.isNegative())return e.isNegative()?this.neg().mul(e.neg()):this.neg().mul(e).neg();if(e.isNegative())return this.mul(e.neg()).neg();if(this.lt(A)&&e.lt(A))return p(this.toNumber()*e.toNumber(),this.unsigned);var t=this.high>>>16,n=65535&this.high,r=this.low>>>16,i=65535&this.low,o=e.high>>>16,s=65535&e.high,a=e.low>>>16,u=65535&e.low,l=0,c=0,_=0,f=0;return _+=(f+=i*u)>>>16,c+=(_+=r*u)>>>16,_&=65535,c+=(_+=i*a)>>>16,l+=(c+=n*u)>>>16,c&=65535,l+=(c+=r*a)>>>16,c&=65535,l+=(c+=i*s)>>>16,l+=t*u+n*a+r*s+i*o,y((_&=65535)<<16|(f&=65535),(l&=65535)<<16|(c&=65535),this.unsigned)},m.mul=m.multiply,m.divide=function(e){if(E(e)||(e=g(e)),e.isZero())throw Error("division by zero");var t,n,r;if(h)return this.unsigned||-2147483648!==this.high||-1!==e.low||-1!==e.high?y((this.unsigned?h.div_u:h.div_s)(this.low,this.high,e.low,e.high),h.get_high(),this.unsigned):this;if(this.isZero())return this.unsigned?l:S;if(this.unsigned){if(e.unsigned||(e=e.toUnsigned()),e.gt(this))return l;if(e.gt(this.shru(1)))return d;r=l}else{if(this.eq(I))return e.eq(f)||e.eq(T)?I:e.eq(I)?f:(t=this.shr(1).div(e).shl(1)).eq(S)?e.isNegative()?f:T:(n=this.sub(e.mul(t)),r=t.add(n.div(e)));else if(e.eq(I))return this.unsigned?l:S;if(this.isNegative())return e.isNegative()?this.neg().div(e.neg()):this.neg().div(e).neg();if(e.isNegative())return this.div(e.neg()).neg();r=S}for(n=this;n.gte(e);){t=Math.max(1,Math.floor(n.toNumber()/e.toNumber()));for(var i=Math.ceil(Math.log(t)/Math.LN2),o=i<=48?1:c(2,i-48),s=p(t),a=s.mul(e);a.isNegative()||a.gt(n);)a=(s=p(t-=o,this.unsigned)).mul(e);s.isZero()&&(s=f),r=r.add(s),n=n.sub(a)}return r},m.div=m.divide,m.modulo=function(e){return E(e)||(e=g(e)),h?y((this.unsigned?h.rem_u:h.rem_s)(this.low,this.high,e.low,e.high),h.get_high(),this.unsigned):this.sub(this.div(e).mul(e))},m.mod=m.modulo,m.rem=m.modulo,m.not=function(){return y(~this.low,~this.high,this.unsigned)},m.and=function(e){return E(e)||(e=g(e)),y(this.low&e.low,this.high&e.high,this.unsigned)},m.or=function(e){return E(e)||(e=g(e)),y(this.low|e.low,this.high|e.high,this.unsigned)},m.xor=function(e){return E(e)||(e=g(e)),y(this.low^e.low,this.high^e.high,this.unsigned)},m.shiftLeft=function(e){return E(e)&&(e=e.toInt()),0==(e&=63)?this:e<32?y(this.low<>>32-e,this.unsigned):y(0,this.low<>>e|this.high<<32-e,this.high>>e,this.unsigned):y(this.high>>e-32,0<=this.high?0:-1,this.unsigned)},m.shr=m.shiftRight,m.shiftRightUnsigned=function(e){if(E(e)&&(e=e.toInt()),0===(e&=63))return this;var t=this.high;return e<32?y(this.low>>>e|t<<32-e,t>>>e,this.unsigned):y(32===e?t:t>>>e-32,0,this.unsigned)},m.shru=m.shiftRightUnsigned,m.shr_u=m.shiftRightUnsigned,m.toSigned=function(){return this.unsigned?y(this.low,this.high,!1):this},m.toUnsigned=function(){return this.unsigned?this:y(this.low,this.high,!0)},m.toBytes=function(e){return e?this.toBytesLE():this.toBytesBE()},m.toBytesLE=function(){var e=this.high,t=this.low;return[255&t,t>>>8&255,t>>>16&255,t>>>24,255&e,e>>>8&255,e>>>16&255,e>>>24]},m.toBytesBE=function(){var e=this.high,t=this.low;return[e>>>24,e>>>16&255,e>>>8&255,255&e,t>>>24,t>>>16&255,t>>>8&255,255&t]},r.fromBytes=function(e,t,n){return n?r.fromBytesLE(e,t):r.fromBytesBE(e,t)},r.fromBytesLE=function(e,t){return new r(e[0]|e[1]<<8|e[2]<<16|e[3]<<24,e[4]|e[5]<<8|e[6]<<16|e[7]<<24,t)},r.fromBytesBE=function(e,t){return new r(e[4]<<24|e[5]<<16|e[6]<<8|e[7],e[0]<<24|e[1]<<16|e[2]<<8|e[3],t)}}],ak={},bk.m=_j,bk.c=ak,bk.d=function(e,t,n){bk.o(e,t)||Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:n})},bk.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return bk.d(t,"a",t),t},bk.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},bk.p="",bk(bk.s=2))}),BSON=unwrapExports(bson_common),bson=BSON.bson,Bson=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"serialize",value:function(e){return bson.serialize(e)}},{key:"deserialize",value:function(e){return bson.deserialize(e)}}]),e}(),SdlPacket=function(){function _(){var e=0>24,l[c++]=(16711680&s)>>16,l[c++]=(65280&s)>>8,l[c++]=255&s,1>24,l[c++]=(16711680&a)>>16,l[c++]=(65280&a)>>8,l[c++]=255&a),null!==u&&0>16&255,o[a++]=r>>8&255,o[a++]=255&r;return 2==i?(r=revLookup[e.charCodeAt(t)]<<2|revLookup[e.charCodeAt(t+1)]>>4,o[a++]=255&r):1==i&&(r=revLookup[e.charCodeAt(t)]<<10|revLookup[e.charCodeAt(t+1)]<<4|revLookup[e.charCodeAt(t+2)]>>2,o[a++]=r>>8&255,o[a++]=255&r),o}function tripletToBase64(e){return lookup[e>>18&63]+lookup[e>>12&63]+lookup[e>>6&63]+lookup[63&e]}function encodeChunk(e,t,n){for(var r,i=[],o=t;o>2],i+=lookup[t<<4&63],i+="=="):2==r&&(t=(e[n-2]<<8)+e[n-1],i+=lookup[t>>10],i+=lookup[t>>4&63],i+=lookup[t<<2&63],i+="="),o.push(i),o.join("")}function read(e,t,n,r,i){var o,s,a=8*i-r-1,u=(1<>1,c=-7,_=n?i-1:0,f=n?-1:1,h=e[t+_];for(_+=f,o=h&(1<<-c)-1,h>>=-c,c+=a;0>=-c,c+=r;0>1,f=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:o-1,E=r?1:-1,p=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(a=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-s))<1&&(s--,u*=2),2<=(t+=1<=s+_?f/u:f*Math.pow(2,1-_))*u&&(s++,u/=2),c<=s+_?(a=0,s=c):1<=s+_?(a=(t*u-1)*Math.pow(2,i),s+=_):(a=t*Math.pow(2,_-1)*Math.pow(2,i),s=0));8<=i;e[n+h]=255&a,h+=E,a/=256,i-=8);for(s=s<=kMaxLength())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+kMaxLength().toString(16)+" bytes");return 0|e}function internalIsBuffer(e){return!(null==e||!e._isBuffer)}function byteLength(e,t){if(internalIsBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return utf8ToBytes(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return base64ToBytes(e).length;default:if(r)return utf8ToBytes(e).length;t=(""+t).toLowerCase(),r=!0}}function slowToString(e,t,n){var r=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(t>>>=0))return"";for(e=e||"utf8";;)switch(e){case"hex":return hexSlice(this,t,n);case"utf8":case"utf-8":return utf8Slice(this,t,n);case"ascii":return asciiSlice(this,t,n);case"latin1":case"binary":return latin1Slice(this,t,n);case"base64":return base64Slice(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return utf16leSlice(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}function swap(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function bidirectionalIndexOf(e,t,n,r,i){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):2147483647=e.length){if(i)return-1;n=e.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof t&&(t=Buffer.from(t,r)),internalIsBuffer(t))return 0===t.length?-1:arrayIndexOf(e,t,n,r,i);if("number"==typeof t)return t&=255,Buffer.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):arrayIndexOf(e,[t],n,r,i);throw new TypeError("val must be string, number or Buffer")}function arrayIndexOf(e,t,n,r,i){var o,s=1,a=e.length,u=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;a/=s=2,u/=2,n/=2}function l(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(i){var c=-1;for(o=n;o>>10&1023|55296),c=56320|1023&c),r.push(c),i+=_}return decodeCodePointsArray(r)}Buffer.TYPED_ARRAY_SUPPORT=void 0===global$1.TYPED_ARRAY_SUPPORT||global$1.TYPED_ARRAY_SUPPORT,Buffer.poolSize=8192,Buffer._augment=function(e){return e.__proto__=Buffer.prototype,e},Buffer.from=function(e,t,n){return from(null,e,t,n)},Buffer.TYPED_ARRAY_SUPPORT&&(Buffer.prototype.__proto__=Uint8Array.prototype,Buffer.__proto__=Uint8Array),Buffer.alloc=function(e,t,n){return alloc(null,e,t,n)},Buffer.allocUnsafe=function(e){return allocUnsafe(null,e)},Buffer.allocUnsafeSlow=function(e){return allocUnsafe(null,e)},Buffer.isBuffer=isBuffer,Buffer.compare=function(e,t){if(!internalIsBuffer(e)||!internalIsBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var n=e.length,r=t.length,i=0,o=Math.min(n,r);it&&(e+=" ... ")),""},Buffer.prototype.compare=function(e,t,n,r,i){if(!internalIsBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),t<0||n>e.length||r<0||i>this.length)throw new RangeError("out of range index");if(i<=r&&n<=t)return 0;if(i<=r)return-1;if(n<=t)return 1;if(this===e)return 0;for(var o=(i>>>=0)-(r>>>=0),s=(n>>>=0)-(t>>>=0),a=Math.min(o,s),u=this.slice(r,i),l=e.slice(t,n),c=0;cthis.length)throw new RangeError("Attempt to write outside buffer bounds");r=r||"utf8";for(var o=!1;;)switch(r){case"hex":return hexWrite(this,e,t,n);case"utf8":case"utf-8":return utf8Write(this,e,t,n);case"ascii":return asciiWrite(this,e,t,n);case"latin1":case"binary":return latin1Write(this,e,t,n);case"base64":return base64Write(this,e,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ucs2Write(this,e,t,n);default:if(o)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),o=!0}},Buffer.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var MAX_ARGUMENTS_LENGTH=4096;function decodeCodePointsArray(e){var t=e.length;if(t<=MAX_ARGUMENTS_LENGTH)return String.fromCharCode.apply(String,e);for(var n="",r=0;re.length)throw new RangeError("Index out of range")}function objectWriteUInt16(e,t,n,r){t<0&&(t=65535+t+1);for(var i=0,o=Math.min(e.length-n,2);i>>8*(r?i:1-i)}function objectWriteUInt32(e,t,n,r){t<0&&(t=4294967295+t+1);for(var i=0,o=Math.min(e.length-n,4);i>>8*(r?i:3-i)&255}function checkIEEE754(e,t,n,r,i,o){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function writeFloat(e,t,n,r,i){return i||checkIEEE754(e,t,n,4),write(e,t,n,r,23,4),n+4}function writeDouble(e,t,n,r,i){return i||checkIEEE754(e,t,n,8),write(e,t,n,r,52,8),n+8}Buffer.prototype.slice=function(e,t){var n,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):r>>8):objectWriteUInt16(this,e,t,!0),t+2},Buffer.prototype.writeUInt16BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,2,65535,0),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):objectWriteUInt16(this,e,t,!1),t+2},Buffer.prototype.writeUInt32LE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,4294967295,0),Buffer.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):objectWriteUInt32(this,e,t,!0),t+4},Buffer.prototype.writeUInt32BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,4294967295,0),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):objectWriteUInt32(this,e,t,!1),t+4},Buffer.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);checkInt(this,e,t,n,i-1,-i)}var o=0,s=1,a=0;for(this[t]=255&e;++o>0)-a&255;return t+n},Buffer.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);checkInt(this,e,t,n,i-1,-i)}var o=n-1,s=1,a=0;for(this[t+o]=255&e;0<=--o&&(s*=256);)e<0&&0===a&&0!==this[t+o+1]&&(a=1),this[t+o]=(e/s>>0)-a&255;return t+n},Buffer.prototype.writeInt8=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,1,127,-128),Buffer.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},Buffer.prototype.writeInt16LE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,2,32767,-32768),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):objectWriteUInt16(this,e,t,!0),t+2},Buffer.prototype.writeInt16BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,2,32767,-32768),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):objectWriteUInt16(this,e,t,!1),t+2},Buffer.prototype.writeInt32LE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,2147483647,-2147483648),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):objectWriteUInt32(this,e,t,!0),t+4},Buffer.prototype.writeInt32BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):objectWriteUInt32(this,e,t,!1),t+4},Buffer.prototype.writeFloatLE=function(e,t,n){return writeFloat(this,e,t,!0,n)},Buffer.prototype.writeFloatBE=function(e,t,n){return writeFloat(this,e,t,!1,n)},Buffer.prototype.writeDoubleLE=function(e,t,n){return writeDouble(this,e,t,!0,n)},Buffer.prototype.writeDoubleBE=function(e,t,n){return writeDouble(this,e,t,!1,n)},Buffer.prototype.copy=function(e,t,n,r){if(n=n||0,r||0===r||(r=this.length),t>=e.length&&(t=e.length),t=t||0,0=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t>>=0,n=void 0===n?this.length:n>>>0,"number"==typeof(e=e||0))for(o=t;o>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;o.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return o}function asciiToBytes(e){for(var t=[],n=0;n>8,i=n%256,o.push(i),o.push(r);return o}function base64ToBytes(e){return toByteArray(base64clean(e))}function blitBuffer(e,t,n,r){for(var i=0;i=t.length||i>=e.length);++i)t[i+n]=e[i];return i}function isnan(e){return e!=e}function isBuffer(e){return null!=e&&(!!e._isBuffer||isFastBuffer(e)||isSlowBuffer(e))}function isFastBuffer(e){return!!e.constructor&&"function"==typeof e.constructor.isBuffer&&e.constructor.isBuffer(e)}function isSlowBuffer(e){return"function"==typeof e.readFloatLE&&"function"==typeof e.slice&&isFastBuffer(e.slice(0,0))}var TextEncoder=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"encode",value:function(e){for(var t=e.length,n=-1,r=[],i=0,o=0,s=0;s!==t;){if(i=e.charCodeAt(s),s+=1,55296<=i&&i<=56319){if(s===t){r[n+=1]=239,r[n+=1]=191,r[n+=1]=189;break}if(!(56320<=(o=e.charCodeAt(s))&&o<=57343)){r[n+=1]=239,r[n+=1]=191,r[n+=1]=189;continue}if(s+=1,65535<(i=1024*(i-55296)+o-56320+65536)){r[n+=1]=240|i>>>18,r[n+=1]=128|i>>>12&63,r[n+=1]=128|i>>>6&63,r[n+=1]=128|63&i;continue}}i<=127?r[n+=1]=0|i:(i<=2047?r[n+=1]=192|i>>>6:(r[n+=1]=224|i>>>12,r[n+=1]=128|i>>>6&63),r[n+=1]=128|63&i)}return r.length=n+1,r}}]),e}(),JsonRpcMarshaller=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"marshall",value:function(e){var t=null;try{var n=function e(t){var n=t.getParameters();for(var r in n)n[r]instanceof RpcStruct&&(n[r]=e(n[r]));return n}(e),r=JSON.stringify(n);t=this._encode(r)}catch(e){console.error("Failed to encode messages to JSON.",e)}return t}},{key:"unmarshall",value:function(e){var t=null;try{var n=this._decode(e);t=JSON.parse(n)}catch(e){console.error("Failed to parse JSON",e)}return t}},{key:"_encode",value:function(e){return new Uint8Array(TextEncoder.encode(e))}},{key:"_decode",value:function(e){return Buffer.from(e).toString()}}]),e}(),BinaryFrameHeader=function(){function l(e,t,n,r){_classCallCheck(this,l),this._rpcType=e,this._functionId=t,this._correlationId=n,this._jsonSize=r,this._bulkData=null,this._jsonData=null}return _createClass(l,[{key:"assembleHeaderBytes",value:function(){var e=[],t=this._functionId,n=this._correlationId;this._rpcType;e.push((251658240&t)>>24),e.push((16711680&t)>>16),e.push((65280&t)>>8),e.push(255&t),e.push((4278190080&n)>>24),e.push((16711680&n)>>16),e.push((65280&n)>>8),e.push(255&n);var r=this._jsonSize;return e.push((4278190080&r)>>24),e.push((16711680&r)>>16),e.push((65280&r)>>8),e.push(255&r),e}},{key:"setRpcType",value:function(e){return this._rpcType=e,this}},{key:"getRpcType",value:function(){return this._rpcType}},{key:"setFunctionId",value:function(e){return this._functionId=e,this}},{key:"getFunctionId",value:function(){return this._functionId}},{key:"setCorrelationId",value:function(e){return this._correlationId=e,this}},{key:"getCorrelationId",value:function(){return this._correlationId}},{key:"setJsonSize",value:function(e){return this._jsonSize=e,this}},{key:"getJsonSize",value:function(){return this._jsonSize}},{key:"getJsonData",value:function(){return this._jsonData}},{key:"setJsonData",value:function(e){return this._jsonData=e,this}},{key:"setBulkData",value:function(e){return this._bulkData=e,this}},{key:"getBulkData",value:function(){return this._bulkData}}],[{key:"fromBinaryHeader",value:function(e){var t=e[0]>>4,n=(15&e[0])<<24;n+=(255&e[1])<<16,n+=(255&e[2])<<8,n+=255&e[3];var r=(255&e[4])<<24;r+=(255&e[5])<<16,r+=(255&e[6])<<8,r+=255&e[7];var i=(255&e[8])<<24;i+=(255&e[9])<<16,i+=(255&e[10])<<8;var o=new l(t,n,r,i+=255&e[11]),s=l.HEADER_SIZE,a=l.HEADER_SIZE+i;if(o.setJsonData(e.slice(s,a)),e.length>a){var u=e.slice(a);o.setBulkData(u)}return o}}]),l}();BinaryFrameHeader.HEADER_SIZE=12;var MessageFrameDisassembler=function(){function u(e,t,n,r,i,o,s){if(_classCallCheck(this,u),this._rpcRequest=e,this._sessionId=t,this._messageId=n,this._isEncrypted=o,!r)throw new Error("MTU must be specified.");if(this._mtu=r,!i)throw new Error("Version must be specified.");this._version=i,this._packetCallback=s}return _createClass(u,[{key:"_buildRPCMainBuffer",value:function(){var e=this._rpcRequest.getBulkData(),t=this._rpcRequest.getCorrelationId(),n=this._rpcRequest.getRPCType(),r=this._rpcRequest.getFunctionName(),i=FunctionID.valueForKey(r);if(!i)throw new Error("Failed to find function ".concat(r));var o=JsonRpcMarshaller.marshall(this._rpcRequest),s=o.length,a=new BinaryFrameHeader(n,i,t);a.setJsonData(o),a.setJsonSize(s),a.setBulkData(e);var u=a.getBulkData(),l=0;u&&(l=u.length);var c=new Uint8Array(12+s+l);return c.set(a.assembleHeaderBytes(),0),c.set(o,12),u&&c.set(u,12+s),c}},{key:"_doRequest",value:function(){var e=this._version,t=FrameType.SINGLE,n=SdlPacket.SERVICE_TYPE_RPC,r=this._sessionId,i=this._messageId,o=this._isEncrypted,s=this._buildRPCMainBuffer(),a=this._mtu,u=Math.ceil(s.length/a);if(u<=1){var l=this._constructPacket(e,n,0,r,i,t,s,o);this._packetCallback(l)}else{var c=new ArrayBuffer(8),_=new DataView(c);_.setUint32(0,s.length,!1),_.setUint32(4,u,!1);var f=new Uint8Array(c),h=this._constructPacket(e,n,0,r,i,FrameType.FIRST,f,o);this._packetCallback(h),this._buildConsecutiveFrames(e,n,r,i,s,a,o)}}},{key:"_constructPacket",value:function(e,t,n,r,i,o,s,a){var u=s.length;return new SdlPacket(e,a,o,t,n,r,u,i,s,0,u)}},{key:"_buildConsecutiveFrames",value:function(e,t,n,r,i,o,s){for(var a,u=0,l=0;0!==a;){a=l+o>=i.length?0:u%255+1;var c=this._constructPacket(e,t,a,n,r,FrameType.CONSECUTIVE,i.slice(l,l+o),s);this._packetCallback(c),u++,l+=o}}}],[{key:"buildRPC",value:function(e,t,n,r,i,o,s){var a=new u(e,t,n,r,i,o,s);return a._doRequest(),a}}]),u}(),TransportListener=function(){function e(){_classCallCheck(this,e),this._onTransportConnected=null,this._onTransportDisconnected=null,this._onError=null,this._onPacketReceived=null}return _createClass(e,[{key:"setOnTransportConnected",value:function(e){return this._onTransportConnected=e,this}},{key:"setOnTransportDisconnected",value:function(e){return this._onTransportDisconnected=e,this}},{key:"setOnError",value:function(e){return this._onError=e,this}},{key:"setOnPacketReceived",value:function(e){return this._onPacketReceived=e,this}},{key:"onTransportConnected",value:function(){"function"==typeof this._onTransportConnected&&this._onTransportConnected()}},{key:"onTransportDisconnected",value:function(){"function"==typeof this._onTransportDisconnected&&this._onTransportDisconnected()}},{key:"onError",value:function(e){var t=0e.getMajor())return 1;if(this.getMajor()===e.getMajor()){if(this.getMinor()>e.getMinor())return 1;if(this.getMinor()===e.getMinor()){if(this.getPatch()>e.getPatch())return 1;if(this.getPatch()===e.getPatch())return 0}}return-1}}]),r}(),ServiceType=function(){function t(){return _classCallCheck(this,t),_possibleConstructorReturn(this,_getPrototypeOf(t).call(this))}return _inherits(t,Enum),_createClass(t,null,[{key:"valueForKey",value:function(e){return t._valueForKey(e,t._MAP)}},{key:"keyForValue",value:function(e){return t._keyForValue(e,t._MAP)}},{key:"CONTROL",get:function(){return t._MAP.CONTROL}},{key:"RPC",get:function(){return t._MAP.RPC}},{key:"AUDIO",get:function(){return t._MAP.AUDIO}},{key:"VIDEO",get:function(){return t._MAP.VIDEO}},{key:"HYBRID",get:function(){return t._MAP.HYBRID}}]),t}();ServiceType._MAP=Object.freeze({CONTROL:0,RPC:7,AUDIO:10,VIDEO:11,HYBRID:15});var MessageFrameAssembler=function(){function t(e){if(_classCallCheck(this,t),"function"!=typeof e)throw new Error("Callback not of expected type (function) for MessageFrameAssembler");this._callback=e,this._accumulator=[],this._totalConsecutiveFrames=0,this._consecutiveFramesHandledCount=0,this._consecutiveFramesDataLength=0}return _createClass(t,[{key:"handleFrame",value:function(e){var t=e.getFrameType();return t!==FrameType.FIRST&&t!==FrameType.CONSECUTIVE?this._callback(null,e):this._handleMultiFrameMessage(e)}},{key:"_handleFirstDataFrame",value:function(e){var t=e.getPayload();if(t instanceof Uint8Array!=!0||8!==t.length)throw new Error("Error handling first frame. Payload is an invalid length should be length 8.");for(var n in t)if(n<0||255>4,0===this._version?n.ERROR_STATE:(this._encryption=1==(e&n.ENCRYPTION_MASK)>>3,this._frameType=e&n.FRAME_TYPE_MASK,(this._version<1||5FrameType.CONSECUTIVE?n.ERROR_STATE:n.SERVICE_TYPE_STATE);if(t===n.SERVICE_TYPE_STATE)return this._serviceType=255&e,n.CONTROL_FRAME_INFO_STATE;if(t===n.CONTROL_FRAME_INFO_STATE){switch(this._controlFrameInfo=255&e,this._frameType){case FrameType.CONTROL:break;case FrameType.SINGLE:case FrameType.FIRST:if(0!==this._controlFrameInfo)return n.ERROR_STATE;break;case FrameType.CONSECUTIVE:break;default:return n.ERROR_STATE}return n.SESSION_ID_STATE}if(t===n.SESSION_ID_STATE)return this._sessionID=255&e,n.DATA_SIZE_1_STATE;if(t===n.DATA_SIZE_1_STATE)return this._dataLength+=(255&e)<<24,n.DATA_SIZE_2_STATE;if(t===n.DATA_SIZE_2_STATE)return this._dataLength+=(255&e)<<16,n.DATA_SIZE_3_STATE;if(t===n.DATA_SIZE_3_STATE)return this._dataLength+=(255&e)<<8,n.DATA_SIZE_4_STATE;if(t!==n.DATA_SIZE_4_STATE)return t===n.MESSAGE_1_STATE?(this._messageID+=(255&e)<<24,n.MESSAGE_2_STATE):t===n.MESSAGE_2_STATE?(this._messageID+=(255&e)<<16,n.MESSAGE_3_STATE):t===n.MESSAGE_3_STATE?(this._messageID+=(255&e)<<8,n.MESSAGE_4_STATE):t===n.MESSAGE_4_STATE?(this._messageID+=255&e,0===this._dataLength?n.FINISHED_STATE:(this._dumpSize=this._dataLength,this._payload=new Uint8Array(this._dataLength),n.DATA_PUMP_STATE)):t===n.DATA_PUMP_STATE?(this._payload[this._dataLength-this._dumpSize]=e,this._dumpSize-=1,0=n())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+n().toString(16)+" bytes");return 0|e}function h(e,t){if(c.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return b(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return U(e).length;default:if(r)return b(e).length;t=(""+t).toLowerCase(),r=!0}}function A(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function T(e,t,n,r,i){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):2147483647=e.length){if(i)return-1;n=e.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof t&&(t=c.from(t,r)),c.isBuffer(t))return 0===t.length?-1:f(e,t,n,r,i);if("number"==typeof t)return t&=255,c.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):f(e,[t],n,r,i);throw new TypeError("val must be string, number or Buffer")}function f(e,t,n,r,i){var a,s=1,u=e.length,o=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;u/=s=2,o/=2,n/=2}function _(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(i){var l=-1;for(a=n;a>8,i=n%256,a.push(i),a.push(r);return a}(t,e.length-n),e,n,r)}function I(e,t,n){return 0===t&&n===e.length?r.fromByteArray(e):r.fromByteArray(e.slice(t,n))}function p(e,t,n){n=Math.min(e.length,n);for(var r=[],i=t;i>>10&1023|55296),l=56320|1023&l),r.push(l),i+=c}return function(e){var t=e.length;if(t<=R)return String.fromCharCode.apply(String,e);var n="",r=0;for(;rthis.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(t>>>=0))return"";for(e=e||"utf8";;)switch(e){case"hex":return O(this,t,n);case"utf8":case"utf-8":return p(this,t,n);case"ascii":return g(this,t,n);case"latin1":case"binary":return C(this,t,n);case"base64":return I(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return v(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}.apply(this,arguments)},c.prototype.equals=function(e){if(!c.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===c.compare(this,e)},c.prototype.inspect=function(){var e="",t=F.INSPECT_MAX_BYTES;return 0t&&(e+=" ... ")),""},c.prototype.compare=function(e,t,n,r,i){if(!c.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),t<0||n>e.length||r<0||i>this.length)throw new RangeError("out of range index");if(i<=r&&n<=t)return 0;if(i<=r)return-1;if(n<=t)return 1;if(this===e)return 0;for(var a=(i>>>=0)-(r>>>=0),s=(n>>>=0)-(t>>>=0),u=Math.min(a,s),o=this.slice(r,i),_=e.slice(t,n),l=0;lthis.length)throw new RangeError("Attempt to write outside buffer bounds");r=r||"utf8";for(var a,s,u,o,_,l,c=!1;;)switch(r){case"hex":return S(this,e,t,n);case"utf8":case"utf-8":return _=t,l=n,B(b(e,(o=this).length-_),o,_,l);case"ascii":return y(this,e,t,n);case"latin1":case"binary":return y(this,e,t,n);case"base64":return a=this,s=t,u=n,B(U(e),a,s,u);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return P(this,e,t,n);default:if(c)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),c=!0}},c.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var R=4096;function g(e,t,n){var r="";n=Math.min(e.length,n);for(var i=t;ie.length)throw new RangeError("Index out of range")}function m(e,t,n,r){t<0&&(t=65535+t+1);for(var i=0,a=Math.min(e.length-n,2);i>>8*(r?i:1-i)}function d(e,t,n,r){t<0&&(t=4294967295+t+1);for(var i=0,a=Math.min(e.length-n,4);i>>8*(r?i:3-i)&255}function L(e,t,n,r){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function k(e,t,n,r,i){return i||L(e,0,n,4),a.write(e,t,n,r,23,4),n+4}function M(e,t,n,r,i){return i||L(e,0,n,8),a.write(e,t,n,r,52,8),n+8}c.prototype.slice=function(e,t){var n,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):r>>8):m(this,e,t,!0),t+2},c.prototype.writeUInt16BE=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,2,65535,0),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):m(this,e,t,!1),t+2},c.prototype.writeUInt32LE=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,4,4294967295,0),c.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):d(this,e,t,!0),t+4},c.prototype.writeUInt32BE=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,4,4294967295,0),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):d(this,e,t,!1),t+4},c.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);D(this,e,t,n,i-1,-i)}var a=0,s=1,u=0;for(this[t]=255&e;++a>0)-u&255;return t+n},c.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);D(this,e,t,n,i-1,-i)}var a=n-1,s=1,u=0;for(this[t+a]=255&e;0<=--a&&(s*=256);)e<0&&0===u&&0!==this[t+a+1]&&(u=1),this[t+a]=(e/s>>0)-u&255;return t+n},c.prototype.writeInt8=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,1,127,-128),c.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},c.prototype.writeInt16LE=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,2,32767,-32768),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):m(this,e,t,!0),t+2},c.prototype.writeInt16BE=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,2,32767,-32768),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):m(this,e,t,!1),t+2},c.prototype.writeInt32LE=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,4,2147483647,-2147483648),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):d(this,e,t,!0),t+4},c.prototype.writeInt32BE=function(e,t,n){return e=+e,t|=0,n||D(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):d(this,e,t,!1),t+4},c.prototype.writeFloatLE=function(e,t,n){return k(this,e,t,!0,n)},c.prototype.writeFloatBE=function(e,t,n){return k(this,e,t,!1,n)},c.prototype.writeDoubleLE=function(e,t,n){return M(this,e,t,!0,n)},c.prototype.writeDoubleBE=function(e,t,n){return M(this,e,t,!1,n)},c.prototype.copy=function(e,t,n,r){if(n=n||0,r||0===r||(r=this.length),t>=e.length&&(t=e.length),t=t||0,0=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t>>=0,n=void 0===n?this.length:n>>>0,"number"==typeof(e=e||0))for(a=t;a>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;a.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;a.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return a}function U(e){return r.toByteArray(Y(e))}function B(e,t,n,r){for(var i=0;i=t.length||i>=e.length);++i)t[i+n]=e[i];return i}}).call(F,V(0))},function(module,exports,__webpack_require__){(function(global,Buffer){var iu;iu=function(exports,_long,buffer){_long=_long&&_long.hasOwnProperty("default")?_long.default:_long,buffer=buffer&&buffer.hasOwnProperty("default")?buffer.default:buffer;var commonjsGlobal="undefined"!=typeof window?window:void 0!==global?global:"undefined"!=typeof self?self:{};function createCommonjsModule(e,t){return e(t={exports:{}},t.exports),t.exports}function getCjsExportFromNamespace(e){return e&&e.default||e}var map=createCommonjsModule(function(e){if(void 0!==commonjsGlobal.Map)e.exports=commonjsGlobal.Map,e.exports.Map=commonjsGlobal.Map;else{var t=function(e){this._keys=[],this._values={};for(var t=0;t>8&255,n[1]=e>>16&255,n[0]=e>>24&255,n[4]=PROCESS_UNIQUE[0],n[5]=PROCESS_UNIQUE[1],n[6]=PROCESS_UNIQUE[2],n[7]=PROCESS_UNIQUE[3],n[8]=PROCESS_UNIQUE[4],n[11]=255&t,n[10]=t>>8&255,n[9]=t>>16&255,n}},{key:"createPk",value:function(){return new i}},{key:"createFromTime",value:function(e){var t=Buffer$1.from([0,0,0,0,0,0,0,0,0,0,0,0]);return t[3]=255&e,t[2]=e>>8&255,t[1]=e>>16&255,t[0]=e>>24&255,new i(t)}},{key:"createFromHexString",value:function(e){if(void 0===e||null!=e&&24!==e.length)throw new TypeError("Argument passed in must be a single String of 12 bytes or a string of 24 hex characters");if(hasBufferType)return new i(Buffer$1.from(e,"hex"));for(var t=new _Buffer(12),n=0,r=0;r<24;)t[n++]=decodeLookup[e.charCodeAt(r++)]<<4|decodeLookup[e.charCodeAt(r++)];return new i(t)}},{key:"isValid",value:function(e){return null!=e&&("number"==typeof e||("string"==typeof e?12===e.length||24===e.length&&checkForHexRegExp.test(e):e instanceof i||(e instanceof _Buffer&&12===e.length||!!e.toHexString&&(12===e.id.length||24===e.id.length&&checkForHexRegExp.test(e.id)))))}},{key:"fromExtendedJSON",value:function(e){return new i(e.$oid)}}]),i}();ObjectId.get_inc=deprecate$1(function(){return ObjectId.getInc()},"Please use the static `ObjectId.getInc()` instead"),ObjectId.prototype.get_inc=deprecate$1(function(){return ObjectId.getInc()},"Please use the static `ObjectId.getInc()` instead"),ObjectId.prototype.getInc=deprecate$1(function(){return ObjectId.getInc()},"Please use the static `ObjectId.getInc()` instead"),ObjectId.prototype.generate=deprecate$1(function(e){return ObjectId.generate(e)},"Please use the static `ObjectId.generate(time)` instead"),Object.defineProperty(ObjectId.prototype,"generationTime",{enumerable:!0,get:function(){return this.id[3]|this.id[2]<<8|this.id[1]<<16|this.id[0]<<24},set:function(e){this.id[3]=255&e,this.id[2]=e>>8&255,this.id[1]=e>>16&255,this.id[0]=e>>24&255}}),ObjectId.prototype[util$2.inspect.custom||"inspect"]=ObjectId.prototype.toString,ObjectId.index=~~(16777215*Math.random()),Object.defineProperty(ObjectId.prototype,"_bsontype",{value:"ObjectID"});var objectid=ObjectId;function _classCallCheck$3(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _defineProperties$3(e,t){for(var n=0;n>>0,r=t.high>>>0;return n>>0>>0}function invalidErr(e,t){throw new TypeError('"'.concat(e,'" is not a valid Decimal128 string - ').concat(t))}function Decimal128(e){this.bytes=e}Decimal128.fromString=function(e){var t,n=!1,r=!1,i=!1,a=0,s=0,u=0,o=0,_=0,l=[0],c=0,E=0,h=0,A=0,T=0,f=0,S=[0,0],y=[0,0],P=0;if(7e3<=e.length)throw new TypeError(e+" not a valid Decimal128 string");var I=e.match(PARSE_STRING_REGEXP),p=e.match(PARSE_INF_REGEXP),R=e.match(PARSE_NAN_REGEXP);if(!I&&!p&&!R||0===e.length)throw new TypeError(e+" not a valid Decimal128 string");if(I){var g=I[2],C=I[4],O=I[5],v=I[6];C&&void 0===v&&invalidErr(e,"missing exponent power"),C&&void 0===g&&invalidErr(e,"missing exponent base"),void 0===C&&(O||v)&&invalidErr(e,"missing e before exponent")}if("+"!==e[P]&&"-"!==e[P]||(n="-"===e[P++]),!isDigit(e[P])&&"."!==e[P]){if("i"===e[P]||"I"===e[P])return new Decimal128(Buffer$2.from(n?INF_NEGATIVE_BUFFER:INF_POSITIVE_BUFFER));if("N"===e[P])return new Decimal128(Buffer$2.from(NAN_BUFFER))}for(;isDigit(e[P])||"."===e[P];)"."!==e[P]?(c<34&&("0"===e[P]&&!i||(i||(_=s),i=!0,l[E++]=parseInt(e[P],10),c+=1)),i&&(u+=1),r&&(o+=1),s+=1):(r&&invalidErr(e,"contains multiple periods"),r=!0),P+=1;if(r&&!s)throw new TypeError(e+" not a valid Decimal128 string");if("e"===e[P]||"E"===e[P]){var N=e.substr(++P).match(EXPONENT_REGEX);if(!N||!N[2])return new Decimal128(Buffer$2.from(NAN_BUFFER));T=parseInt(N[0],10),P+=N[0].length}if(e[P])return new Decimal128(Buffer$2.from(NAN_BUFFER));if(h=0,c){if(A=c-1,1!==(a=u))for(;"0"===e[_+a-1];)a-=1}else c=u=1,a=l[A=h=0]=0;for(T<=o&&16384>8&255,b[P++]=K.low.low>>16&255,b[P++]=K.low.low>>24&255,b[P++]=255&K.low.high,b[P++]=K.low.high>>8&255,b[P++]=K.low.high>>16&255,b[P++]=K.low.high>>24&255,b[P++]=255&K.high.low,b[P++]=K.high.low>>8&255,b[P++]=K.high.low>>16&255,b[P++]=K.high.low>>24&255,b[P++]=255&K.high.high,b[P++]=K.high.high>>8&255,b[P++]=K.high.high>>16&255,b[P++]=K.high.high>>24&255,new Decimal128(b)};var COMBINATION_MASK=31,EXPONENT_MASK=16383,COMBINATION_INFINITY=30,COMBINATION_NAN=31;Decimal128.prototype.toString=function(){for(var e,t,n,r,i,a,s=0,u=new Array(36),o=0;o>26&COMBINATION_MASK)>>3==3){if(i===COMBINATION_INFINITY)return S.join("")+"Infinity";if(i===COMBINATION_NAN)return"NaN";a=e>>15&EXPONENT_MASK,c=8+(e>>14&1)}else c=e>>14&7,a=e>>17&EXPONENT_MASK;if(_=a-EXPONENT_BIAS,f.parts[0]=(16383&e)+((15&c)<<14),f.parts[1]=t,f.parts[2]=n,f.parts[3]=r,0===f.parts[0]&&0===f.parts[1]&&0===f.parts[2]&&0===f.parts[3])T=!0;else for(h=3;0<=h;h--){var P=0,I=divideu128(f);if(f=I.quotient,P=I.rem.low)for(E=8;0<=E;E--)u[9*h+E]=P%10,P=Math.floor(P/10)}if(T)s=1,u[A]=0;else for(s=36;!u[A];)s-=1,A+=1;if(34<=(l=s-1+_)||l<=-7||0<_){if(34this.position)this.buffer[this.position++]=t;else if(void 0!==Buffer$3&&Buffer$3.isBuffer(this.buffer)){var n=Buffer$3.alloc(a.BUFFER_SIZE+this.buffer.length);this.buffer.copy(n,0,0,this.buffer.length),this.buffer=n,this.buffer[this.position++]=t}else{var r=null;r=isUint8Array(this.buffer)?new Uint8Array(new ArrayBuffer(a.BUFFER_SIZE+this.buffer.length)):new Array(a.BUFFER_SIZE+this.buffer.length);for(var i=0;ithis.position?t+e.length:this.position;else if(void 0!==Buffer$3&&"string"==typeof e&&Buffer$3.isBuffer(this.buffer))this.buffer.write(e,t,"binary"),this.position=t+e.length>this.position?t+e.length:this.position;else if(isUint8Array(e)||Array.isArray(e)&&"string"!=typeof e){for(var i=0;ithis.position?t:this.position}else if("string"==typeof e){for(var a=0;athis.position?t:this.position}}},{key:"read",value:function(e,t){if(t=t&&0= 5, is ".concat(i));if(t.allowObjectSmallerThanBufferSize&&e.length= bson size ").concat(i));if(!t.allowObjectSmallerThanBufferSize&&e.length!==i)throw new Error("buffer length ".concat(e.length," must === bson size ").concat(i));if(i+r>e.length)throw new Error("(bson size ".concat(i," + options.index ").concat(r," must be <= buffer length ").concat(Buffer$4.byteLength(e),")"));if(0!==e[r+i-1])throw new Error("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");return deserializeObject(e,r,t,n)}function deserializeObject(e,t,n,r){var i=null!=n.evalFunctions&&n.evalFunctions,a=null!=n.cacheFunctions&&n.cacheFunctions,s=null!=n.cacheFunctionsCrc32&&n.cacheFunctionsCrc32;if(!s)var u=null;var o=null==n.fieldsAsRaw?null:n.fieldsAsRaw,_=null!=n.raw&&n.raw,l="boolean"==typeof n.bsonRegExp&&n.bsonRegExp,c=null!=n.promoteBuffers&&n.promoteBuffers,E=null==n.promoteLongs||n.promoteLongs,h=null==n.promoteValues||n.promoteValues,A=t;if(e.length<5)throw new Error("corrupt bson message < 5 bytes long");var T=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(T<5||T>e.length)throw new Error("corrupt bson message");for(var f=r?[]:{},S=0;;){var y=e[t++];if(0===y)break;for(var P=t;0!==e[P]&&P=Buffer$4.byteLength(e))throw new Error("Bad BSON Document: illegal CString");var I=r?S++:e.toString("utf8",t,P);if(t=P+1,y===constants.BSON_DATA_STRING){var p=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(p<=0||p>e.length-t||0!==e[t+p-1])throw new Error("bad string length in bson");if(!validateUtf8$1(e,t,t+p-1))throw new Error("Invalid UTF-8 string in BSON document");var R=e.toString("utf8",t,t+p-1);f[I]=R,t+=p}else if(y===constants.BSON_DATA_OID){var g=Buffer$4.alloc(12);e.copy(g,0,t,t+12),f[I]=new objectid(g),t+=12}else if(y===constants.BSON_DATA_INT&&!1===h)f[I]=new int_32(e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24);else if(y===constants.BSON_DATA_INT)f[I]=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;else if(y===constants.BSON_DATA_NUMBER&&!1===h)f[I]=new double_1(e.readDoubleLE(t)),t+=8;else if(y===constants.BSON_DATA_NUMBER)f[I]=e.readDoubleLE(t),t+=8;else if(y===constants.BSON_DATA_DATE){var C=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,O=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;f[I]=new Date(new long_1(C,O).toNumber())}else if(y===constants.BSON_DATA_BOOLEAN){if(0!==e[t]&&1!==e[t])throw new Error("illegal boolean type value");f[I]=1===e[t++]}else if(y===constants.BSON_DATA_OBJECT){var v=t,N=e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24;if(N<=0||N>e.length-t)throw new Error("bad embedded document length in bson");f[I]=_?e.slice(t,t+N):deserializeObject(e,v,n,!1),t+=N}else if(y===constants.BSON_DATA_ARRAY){var D=t,m=e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24,d=n,L=t+m;if(o&&o[I]){for(var k in d={},n)d[k]=n[k];d.raw=!0}if(f[I]=deserializeObject(e,D,d,!0),0!==e[(t+=m)-1])throw new Error("invalid array terminator byte");if(t!==L)throw new Error("corrupted array bson")}else if(y===constants.BSON_DATA_UNDEFINED)f[I]=void 0;else if(y===constants.BSON_DATA_NULL)f[I]=null;else if(y===constants.BSON_DATA_LONG){var M=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,Y=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,K=new long_1(M,Y);f[I]=E&&!0===h&&K.lessThanOrEqual(JS_INT_MAX_LONG)&&K.greaterThanOrEqual(JS_INT_MIN_LONG)?K.toNumber():K}else if(y===constants.BSON_DATA_DECIMAL128){var b=Buffer$4.alloc(16);e.copy(b,0,t,t+16),t+=16;var U=new decimal128(b);f[I]=U.toObject?U.toObject():U}else if(y===constants.BSON_DATA_BINARY){var B=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,F=B,V=e[t++];if(B<0)throw new Error("Negative binary type element size found");if(B>Buffer$4.byteLength(e))throw new Error("Binary type size larger than document size");if(null!=e.slice){if(V===binary.SUBTYPE_BYTE_ARRAY){if((B=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24)<0)throw new Error("Negative binary type element size found for subtype 0x02");if(F-4=e.length)throw new Error("Bad BSON Document: illegal CString");var H=e.toString("utf8",t,P);for(P=t=P+1;0!==e[P]&&P=e.length)throw new Error("Bad BSON Document: illegal CString");var w=e.toString("utf8",t,P);t=P+1;var W=new Array(w.length);for(P=0;P=e.length)throw new Error("Bad BSON Document: illegal CString");var j=e.toString("utf8",t,P);for(P=t=P+1;0!==e[P]&&P=e.length)throw new Error("Bad BSON Document: illegal CString");var x=e.toString("utf8",t,P);t=P+1,f[I]=new regexp(j,x)}else if(y===constants.BSON_DATA_SYMBOL){var z=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(z<=0||z>e.length-t||0!==e[t+z-1])throw new Error("bad string length in bson");f[I]=e.toString("utf8",t,t+z-1),t+=z}else if(y===constants.BSON_DATA_TIMESTAMP){var X=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24,$=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;f[I]=new timestamp(X,$)}else if(y===constants.BSON_DATA_MIN_KEY)f[I]=new min_key;else if(y===constants.BSON_DATA_MAX_KEY)f[I]=new max_key;else if(y===constants.BSON_DATA_CODE){var Q=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(Q<=0||Q>e.length-t||0!==e[t+Q-1])throw new Error("bad string length in bson");var q=e.toString("utf8",t,t+Q-1);if(i)if(a){var Z=s?u(q):q;f[I]=isolateEvalWithHash(functionCache,Z,q,f)}else f[I]=isolateEval(q);else f[I]=new code(q);t+=Q}else if(y===constants.BSON_DATA_CODE_W_SCOPE){var J=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(J<13)throw new Error("code_w_scope total size shorter minimum expected length");var ee=e[t++]|e[t++]<<8|e[t++]<<16|e[t++]<<24;if(ee<=0||ee>e.length-t||0!==e[t+ee-1])throw new Error("bad string length in bson");var te=e.toString("utf8",t,t+ee-1),ne=t+=ee,re=e[t]|e[t+1]<<8|e[t+2]<<16|e[t+3]<<24,ie=deserializeObject(e,ne,n,!1);if(t+=re,J<8+re+ee)throw new Error("code_w_scope total size is to short, truncating scope");if(8+re+eee.length-t||0!==e[t+se-1])throw new Error("bad string length in bson");if(!validateUtf8$1(e,t,t+se-1))throw new Error("Invalid UTF-8 string in BSON document");var ue=e.toString("utf8",t,t+se-1);t+=se;var oe=Buffer$4.alloc(12);e.copy(oe,0,t,t+12);var _e=new objectid(oe);t+=12,f[I]=new db_ref(ue,_e)}}if(T!=t-A){if(r)throw new Error("corrupt array bson");throw new Error("corrupt object bson")}var le=Object.keys(f).filter(function(e){return e.startsWith("$")}),ce=!0;if(le.forEach(function(e){-1===["$ref","$id","$db"].indexOf(e)&&(ce=!1)}),!ce)return f;if(null==f.$id||null==f.$ref)return f;var Ee=Object.assign({},f);return delete Ee.$ref,delete Ee.$id,delete Ee.$db,new db_ref(f.$ref,f.$id,f.$db||null,Ee)}function isolateEvalWithHash(functionCache,hash,functionString,object){var value=null;return null==functionCache[hash]&&(eval("value = "+functionString),functionCache[hash]=value),functionCache[hash].bind(object)}function isolateEval(functionString){var value=null;return eval("value = "+functionString),value}var deserializer=deserialize$1;function readIEEE754(e,t,n,r,i){var a,s,u="big"===n,o=8*i-r-1,_=(1<>1,c=-7,E=u?0:i-1,h=u?1:-1,A=e[t+E];for(E+=h,a=A&(1<<-c)-1,A>>=-c,c+=o;0>=-c,c+=r;0>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,A=_?a-1:0,T=_?-1:1,f=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(u=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(o=Math.pow(2,-s))<1&&(s--,o*=2),2<=(t+=1<=s+E?h/o:h*Math.pow(2,1-E))*o&&(s++,o/=2),c<=s+E?(u=0,s=c):1<=s+E?(u=(t*o-1)*Math.pow(2,i),s+=E):(u=t*Math.pow(2,E-1)*Math.pow(2,i),s=0)),isNaN(t)&&(u=0);8<=i;)e[n+A]=255&u,A+=T,u/=256,i-=8;for(s=s<>24&255,e[r+2]=s+1>>16&255,e[r+1]=s+1>>8&255,e[r]=s+1&255,r=r+4+s,e[r++]=0,r}function serializeNumber(e,t,n,r,i){if(Math.floor(n)===n&&n>=constants.JS_INT_MIN&&n<=constants.JS_INT_MAX)if(n>=constants.BSON_INT32_MIN&&n<=constants.BSON_INT32_MAX)e[r++]=constants.BSON_DATA_INT,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,e[r++]=255&n,e[r++]=n>>8&255,e[r++]=n>>16&255,e[r++]=n>>24&255;else if(n>=constants.JS_INT_MIN&&n<=constants.JS_INT_MAX){e[r++]=constants.BSON_DATA_NUMBER,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,writeIEEE754$1(e,n,r,"little",52,8),r+=8}else{e[r++]=constants.BSON_DATA_LONG,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a=long_1.fromNumber(n),s=a.getLowBits(),u=a.getHighBits();e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,e[r++]=255&u,e[r++]=u>>8&255,e[r++]=u>>16&255,e[r++]=u>>24&255}else e[r++]=constants.BSON_DATA_NUMBER,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,writeIEEE754$1(e,n,r,"little",52,8),r+=8;return r}function serializeNull(e,t,n,r,i){return e[r++]=constants.BSON_DATA_NULL,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,r}function serializeBoolean(e,t,n,r,i){return e[r++]=constants.BSON_DATA_BOOLEAN,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,e[r++]=n?1:0,r}function serializeDate(e,t,n,r,i){e[r++]=constants.BSON_DATA_DATE,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a=long_1.fromNumber(n.getTime()),s=a.getLowBits(),u=a.getHighBits();return e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,e[r++]=255&u,e[r++]=u>>8&255,e[r++]=u>>16&255,e[r++]=u>>24&255,r}function serializeRegExp(e,t,n,r,i){if(e[r++]=constants.BSON_DATA_REGEXP,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,n.source&&null!=n.source.match(regexp$1))throw Error("value "+n.source+" must not contain null bytes");return r+=e.write(n.source,r,"utf8"),e[r++]=0,n.ignoreCase&&(e[r++]=105),n.global&&(e[r++]=115),n.multiline&&(e[r++]=109),e[r++]=0,r}function serializeBSONRegExp(e,t,n,r,i){if(e[r++]=constants.BSON_DATA_REGEXP,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,null!=n.pattern.match(regexp$1))throw Error("pattern "+n.pattern+" must not contain null bytes");return r+=e.write(n.pattern,r,"utf8"),e[r++]=0,r+=e.write(n.options.split("").sort().join(""),r,"utf8"),e[r++]=0,r}function serializeMinMax(e,t,n,r,i){return null===n?e[r++]=constants.BSON_DATA_NULL:"MinKey"===n._bsontype?e[r++]=constants.BSON_DATA_MIN_KEY:e[r++]=constants.BSON_DATA_MAX_KEY,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,r}function serializeObjectId(e,t,n,r,i){if(e[r++]=constants.BSON_DATA_OID,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,"string"==typeof n.id)e.write(n.id,r,"binary");else{if(!n.id||!n.id.copy)throw new TypeError("object ["+JSON.stringify(n)+"] is not a valid ObjectId");n.id.copy(e,r,0,12)}return r+12}function serializeBuffer(e,t,n,r,i){e[r++]=constants.BSON_DATA_BINARY,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a=n.length;return e[r++]=255&a,e[r++]=a>>8&255,e[r++]=a>>16&255,e[r++]=a>>24&255,e[r++]=constants.BSON_BINARY_SUBTYPE_DEFAULT,n.copy(e,r,0,a),r+=a}function serializeObject(e,t,n,r,i,a,s,u,o,_){for(var l=0;l<_.length;l++)if(_[l]===n)throw new Error("cyclic dependency detected");_.push(n),e[r++]=Array.isArray(n)?constants.BSON_DATA_ARRAY:constants.BSON_DATA_OBJECT,r+=o?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var c=serializeInto(e,n,i,r,a+1,s,u,_);return _.pop(),c}function serializeDecimal128(e,t,n,r,i){return e[r++]=constants.BSON_DATA_DECIMAL128,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,n.bytes.copy(e,r,0,16),r+16}function serializeLong(e,t,n,r,i){e[r++]="Long"===n._bsontype?constants.BSON_DATA_LONG:constants.BSON_DATA_TIMESTAMP,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a=n.getLowBits(),s=n.getHighBits();return e[r++]=255&a,e[r++]=a>>8&255,e[r++]=a>>16&255,e[r++]=a>>24&255,e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,r}function serializeInt32(e,t,n,r,i){return e[r++]=constants.BSON_DATA_INT,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,e[r++]=255&n,e[r++]=n>>8&255,e[r++]=n>>16&255,e[r++]=n>>24&255,r}function serializeDouble(e,t,n,r,i){return e[r++]=constants.BSON_DATA_NUMBER,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0,writeIEEE754$1(e,n.value,r,"little",52,8),r+=8}function serializeFunction(e,t,n,r,i,a,s){e[r++]=constants.BSON_DATA_CODE,r+=s?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var u=normalizedFunctionString$1(n),o=e.write(u,r+4,"utf8")+1;return e[r]=255&o,e[r+1]=o>>8&255,e[r+2]=o>>16&255,e[r+3]=o>>24&255,r=r+4+o-1,e[r++]=0,r}function serializeCode(e,t,n,r,i,a,s,u,o){if(n.scope&&"object"===_typeof$3(n.scope)){e[r++]=constants.BSON_DATA_CODE_W_SCOPE,r+=o?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var _=r,l="string"==typeof n.code?n.code:n.code.toString();r+=4;var c=e.write(l,r+4,"utf8")+1;e[r]=255&c,e[r+1]=c>>8&255,e[r+2]=c>>16&255,e[r+3]=c>>24&255,e[r+4+c-1]=0,r=r+c+4;var E=serializeInto(e,n.scope,i,r,a+1,s,u);r=E-1;var h=E-_;e[_++]=255&h,e[_++]=h>>8&255,e[_++]=h>>16&255,e[_++]=h>>24&255,e[r++]=0}else{e[r++]=constants.BSON_DATA_CODE,r+=o?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var A=n.code.toString(),T=e.write(A,r+4,"utf8")+1;e[r]=255&T,e[r+1]=T>>8&255,e[r+2]=T>>16&255,e[r+3]=T>>24&255,r=r+4+T-1,e[r++]=0}return r}function serializeBinary(e,t,n,r,i){e[r++]=constants.BSON_DATA_BINARY,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a=n.value(!0),s=n.position;return n.sub_type===binary.SUBTYPE_BYTE_ARRAY&&(s+=4),e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255,e[r++]=n.sub_type,n.sub_type===binary.SUBTYPE_BYTE_ARRAY&&(s-=4,e[r++]=255&s,e[r++]=s>>8&255,e[r++]=s>>16&255,e[r++]=s>>24&255),a.copy(e,r,0,n.position),r+=n.position}function serializeSymbol(e,t,n,r,i){e[r++]=constants.BSON_DATA_SYMBOL,r+=i?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var a=e.write(n.value,r+4,"utf8")+1;return e[r]=255&a,e[r+1]=a>>8&255,e[r+2]=a>>16&255,e[r+3]=a>>24&255,r=r+4+a-1,e[r++]=0,r}function serializeDBRef(e,t,n,r,i,a,s){e[r++]=constants.BSON_DATA_OBJECT,r+=s?e.write(t,r,"ascii"):e.write(t,r,"utf8"),e[r++]=0;var u,o=r,_={$ref:n.collection||n.namespace,$id:n.oid};null!=n.db&&(_.$db=n.db);var l=(u=serializeInto(e,_=Object.assign(_,n.fields),!1,r,i+1,a))-o;return e[o++]=255&l,e[o++]=l>>8&255,e[o++]=l>>16&255,e[o++]=l>>24&255,u}function serializeInto(e,t,n,r,i,a,s,u){r=r||0,(u=u||[]).push(t);var o=r+4;if(Array.isArray(t))for(var _=0;_>8&255,e[r++]=R>>16&255,e[r++]=R>>24&255,o}var serializer=serializeInto;function _typeof$4(e){return(_typeof$4="function"==typeof Symbol&&"symbol"===_typeof(Symbol.iterator)?function(e){return _typeof(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":_typeof(e)})(e)}var Buffer$6=buffer.Buffer,normalizedFunctionString$2=utils.normalizedFunctionString;function isDate$2(e){return"object"===_typeof$4(e)&&"[object Date]"===Object.prototype.toString.call(e)}function calculateObjectSize(e,t,n){var r=5;if(Array.isArray(e))for(var i=0;i=constants.JS_INT_MIN&&t<=constants.JS_INT_MAX&&t>=constants.BSON_INT32_MIN&&t<=constants.BSON_INT32_MAX?(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+5:(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+9;case"undefined":return r||!i?(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+1:0;case"boolean":return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+2;case"object":if(null==t||"MinKey"===t._bsontype||"MaxKey"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+1;if("ObjectId"===t._bsontype||"ObjectID"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+13;if(t instanceof Date||isDate$2(t))return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+9;if(void 0!==Buffer$6&&Buffer$6.isBuffer(t))return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+6+t.length;if("Long"===t._bsontype||"Double"===t._bsontype||"Timestamp"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+9;if("Decimal128"===t._bsontype)return(null!=e?Buffer$6.byteLength(e,"utf8")+1:0)+17;if("Code"===t._bsontype)return null!=t.scope&&0>16&255,s[u++]=t>>8&255,s[u++]=255&t;2===a&&(t=_[e.charCodeAt(n)]<<2|_[e.charCodeAt(n+1)]>>4,s[u++]=255&t);1===a&&(t=_[e.charCodeAt(n)]<<10|_[e.charCodeAt(n+1)]<<4|_[e.charCodeAt(n+2)]>>2,s[u++]=t>>8&255,s[u++]=255&t);return s},t.fromByteArray=function(e){for(var t,n=e.length,r=n%3,i=[],a=0,s=n-r;a>2]+u[t<<4&63]+"==")):2==r&&(t=(e[n-2]<<8)+e[n-1],i.push(u[t>>10]+u[t>>4&63]+u[t<<2&63]+"="));return i.join("")};for(var u=[],_=[],l="undefined"!=typeof Uint8Array?Uint8Array:Array,r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,a=r.length;i>18&63]+u[i>>12&63]+u[i>>6&63]+u[63&i]);return a.join("")}_["-".charCodeAt(0)]=62,_["_".charCodeAt(0)]=63},function(e,t){t.read=function(e,t,n,r,i){var a,s,u=8*i-r-1,o=(1<>1,l=-7,c=n?i-1:0,E=n?-1:1,h=e[t+c];for(c+=E,a=h&(1<<-l)-1,h>>=-l,l+=u;0>=-l,l+=r;0>1,E=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:a-1,A=r?1:-1,T=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(u=isNaN(t)?1:0,s=l):(s=Math.floor(Math.log(t)/Math.LN2),t*(o=Math.pow(2,-s))<1&&(s--,o*=2),2<=(t+=1<=s+c?E/o:E*Math.pow(2,1-c))*o&&(s++,o/=2),l<=s+c?(u=0,s=l):1<=s+c?(u=(t*o-1)*Math.pow(2,i),s+=c):(u=t*Math.pow(2,c-1)*Math.pow(2,i),s=0));8<=i;e[n+h]=255&u,h+=A,u/=256,i-=8);for(s=s<>>=0)&&e<256)&&(r=s[e])?r:(n=f(e,(0|e)<0?-1:0,!0),i&&(s[e]=n),n):(i=-128<=(e|=0)&&e<128)&&(r=a[e])?r:(n=f(e,e<0?-1:0,!1),i&&(a[e]=n),n)}function T(e,t){if(isNaN(e))return t?_:P;if(t){if(e<0)return _;if(u<=e)return g}else{if(e<=-o)return C;if(o<=e+1)return R}return e<0?T(-e,t).neg():f(e%i|0,e/i|0,t)}function f(e,t,n){return new r(e,t,n)}r.fromInt=n,r.fromNumber=T,r.fromBits=f;var l=Math.pow;function c(e,t,n){if(0===e.length)throw Error("empty string");if("NaN"===e||"Infinity"===e||"+Infinity"===e||"-Infinity"===e)return P;if(t="number"==typeof t?(n=t,!1):!!t,(n=n||10)<2||36>>0:this.low},O.toNumber=function(){return this.unsigned?(this.high>>>0)*i+(this.low>>>0):this.high*i+(this.low>>>0)},O.toString=function(e){if((e=e||10)<2||36>>0).toString(e);if((a=u).isZero())return o+s;for(;o.length<6;)o="0"+o;s=""+o+s}},O.getHighBits=function(){return this.high},O.getHighBitsUnsigned=function(){return this.high>>>0},O.getLowBits=function(){return this.low},O.getLowBitsUnsigned=function(){return this.low>>>0},O.getNumBitsAbs=function(){if(this.isNegative())return this.eq(C)?64:this.neg().getNumBitsAbs();for(var e=0!=this.high?this.high:this.low,t=31;0>>31!=1||e.high>>>31!=1)&&(this.high===e.high&&this.low===e.low)},O.eq=O.equals,O.notEquals=function(e){return!this.eq(e)},O.neq=O.notEquals,O.ne=O.notEquals,O.lessThan=function(e){return this.comp(e)<0},O.lt=O.lessThan,O.lessThanOrEqual=function(e){return this.comp(e)<=0},O.lte=O.lessThanOrEqual,O.le=O.lessThanOrEqual,O.greaterThan=function(e){return 0>>0>this.high>>>0||e.high===this.high&&e.low>>>0>this.low>>>0?-1:1:this.sub(e).isNegative()?-1:1},O.comp=O.compare,O.negate=function(){return!this.unsigned&&this.eq(C)?C:this.not().add(E)},O.neg=O.negate,O.add=function(e){A(e)||(e=S(e));var t=this.high>>>16,n=65535&this.high,r=this.low>>>16,i=65535&this.low,a=e.high>>>16,s=65535&e.high,u=e.low>>>16,o=0,_=0,l=0,c=0;return l+=(c+=i+(65535&e.low))>>>16,_+=(l+=r+u)>>>16,o+=(_+=n+s)>>>16,o+=t+a,f((l&=65535)<<16|(c&=65535),(o&=65535)<<16|(_&=65535),this.unsigned)},O.subtract=function(e){return A(e)||(e=S(e)),this.add(e.neg())},O.sub=O.subtract,O.multiply=function(e){if(this.isZero())return P;if(A(e)||(e=S(e)),h)return f(h.mul(this.low,this.high,e.low,e.high),h.get_high(),this.unsigned);if(e.isZero())return P;if(this.eq(C))return e.isOdd()?C:P;if(e.eq(C))return this.isOdd()?C:P;if(this.isNegative())return e.isNegative()?this.neg().mul(e.neg()):this.neg().mul(e).neg();if(e.isNegative())return this.mul(e.neg()).neg();if(this.lt(y)&&e.lt(y))return T(this.toNumber()*e.toNumber(),this.unsigned);var t=this.high>>>16,n=65535&this.high,r=this.low>>>16,i=65535&this.low,a=e.high>>>16,s=65535&e.high,u=e.low>>>16,o=65535&e.low,_=0,l=0,c=0,E=0;return c+=(E+=i*o)>>>16,l+=(c+=r*o)>>>16,c&=65535,l+=(c+=i*u)>>>16,_+=(l+=n*o)>>>16,l&=65535,_+=(l+=r*u)>>>16,l&=65535,_+=(l+=i*s)>>>16,_+=t*o+n*u+r*s+i*a,f((c&=65535)<<16|(E&=65535),(_&=65535)<<16|(l&=65535),this.unsigned)},O.mul=O.multiply,O.divide=function(e){if(A(e)||(e=S(e)),e.isZero())throw Error("division by zero");var t,n,r;if(h)return this.unsigned||-2147483648!==this.high||-1!==e.low||-1!==e.high?f((this.unsigned?h.div_u:h.div_s)(this.low,this.high,e.low,e.high),h.get_high(),this.unsigned):this;if(this.isZero())return this.unsigned?_:P;if(this.unsigned){if(e.unsigned||(e=e.toUnsigned()),e.gt(this))return _;if(e.gt(this.shru(1)))return I;r=_}else{if(this.eq(C))return e.eq(E)||e.eq(p)?C:e.eq(C)?E:(t=this.shr(1).div(e).shl(1)).eq(P)?e.isNegative()?E:p:(n=this.sub(e.mul(t)),r=t.add(n.div(e)));else if(e.eq(C))return this.unsigned?_:P;if(this.isNegative())return e.isNegative()?this.neg().div(e.neg()):this.neg().div(e).neg();if(e.isNegative())return this.div(e.neg()).neg();r=P}for(n=this;n.gte(e);){t=Math.max(1,Math.floor(n.toNumber()/e.toNumber()));for(var i=Math.ceil(Math.log(t)/Math.LN2),a=i<=48?1:l(2,i-48),s=T(t),u=s.mul(e);u.isNegative()||u.gt(n);)u=(s=T(t-=a,this.unsigned)).mul(e);s.isZero()&&(s=E),r=r.add(s),n=n.sub(u)}return r},O.div=O.divide,O.modulo=function(e){return A(e)||(e=S(e)),h?f((this.unsigned?h.rem_u:h.rem_s)(this.low,this.high,e.low,e.high),h.get_high(),this.unsigned):this.sub(this.div(e).mul(e))},O.mod=O.modulo,O.rem=O.modulo,O.not=function(){return f(~this.low,~this.high,this.unsigned)},O.and=function(e){return A(e)||(e=S(e)),f(this.low&e.low,this.high&e.high,this.unsigned)},O.or=function(e){return A(e)||(e=S(e)),f(this.low|e.low,this.high|e.high,this.unsigned)},O.xor=function(e){return A(e)||(e=S(e)),f(this.low^e.low,this.high^e.high,this.unsigned)},O.shiftLeft=function(e){return A(e)&&(e=e.toInt()),0==(e&=63)?this:e<32?f(this.low<>>32-e,this.unsigned):f(0,this.low<>>e|this.high<<32-e,this.high>>e,this.unsigned):f(this.high>>e-32,0<=this.high?0:-1,this.unsigned)},O.shr=O.shiftRight,O.shiftRightUnsigned=function(e){if(A(e)&&(e=e.toInt()),0===(e&=63))return this;var t=this.high;return e<32?f(this.low>>>e|t<<32-e,t>>>e,this.unsigned):f(32===e?t:t>>>e-32,0,this.unsigned)},O.shru=O.shiftRightUnsigned,O.shr_u=O.shiftRightUnsigned,O.toSigned=function(){return this.unsigned?f(this.low,this.high,!1):this},O.toUnsigned=function(){return this.unsigned?this:f(this.low,this.high,!0)},O.toBytes=function(e){return e?this.toBytesLE():this.toBytesBE()},O.toBytesLE=function(){var e=this.high,t=this.low;return[255&t,t>>>8&255,t>>>16&255,t>>>24,255&e,e>>>8&255,e>>>16&255,e>>>24]},O.toBytesBE=function(){var e=this.high,t=this.low;return[e>>>24,e>>>16&255,e>>>8&255,255&e,t>>>24,t>>>16&255,t>>>8&255,255&t]},r.fromBytes=function(e,t,n){return n?r.fromBytesLE(e,t):r.fromBytesBE(e,t)},r.fromBytesLE=function(e,t){return new r(e[0]|e[1]<<8|e[2]<<16|e[3]<<24,e[4]|e[5]<<8|e[6]<<16|e[7]<<24,t)},r.fromBytesBE=function(e,t){return new r(e[4]<<24|e[5]<<16|e[6]<<8|e[7],e[0]<<24|e[1]<<16|e[2]<<8|e[3],t)}}],jk={},kk.m=ik,kk.c=jk,kk.d=function(e,t,n){kk.o(e,t)||Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:n})},kk.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return kk.d(t,"a",t),t},kk.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},kk.p="",kk(kk.s=2))}),BSON=unwrapExports(bson_common),bson=BSON.bson,Bson=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"serialize",value:function(e){return bson.serialize(e)}},{key:"deserialize",value:function(e){return bson.deserialize(e)}}]),e}(),SdlPacket=function(){function c(){var e=0>24,_[l++]=(16711680&s)>>16,_[l++]=(65280&s)>>8,_[l++]=255&s,1>24,_[l++]=(16711680&u)>>16,_[l++]=(65280&u)>>8,_[l++]=255&u),null!==o&&0>16&255,a[u++]=r>>8&255,a[u++]=255&r;return 2==i?(r=revLookup[e.charCodeAt(t)]<<2|revLookup[e.charCodeAt(t+1)]>>4,a[u++]=255&r):1==i&&(r=revLookup[e.charCodeAt(t)]<<10|revLookup[e.charCodeAt(t+1)]<<4|revLookup[e.charCodeAt(t+2)]>>2,a[u++]=r>>8&255,a[u++]=255&r),a}function tripletToBase64(e){return lookup[e>>18&63]+lookup[e>>12&63]+lookup[e>>6&63]+lookup[63&e]}function encodeChunk(e,t,n){for(var r,i=[],a=t;a>2],i+=lookup[t<<4&63],i+="=="):2==r&&(t=(e[n-2]<<8)+e[n-1],i+=lookup[t>>10],i+=lookup[t>>4&63],i+=lookup[t<<2&63],i+="="),a.push(i),a.join("")}function read(e,t,n,r,i){var a,s,u=8*i-r-1,o=(1<>1,l=-7,c=n?i-1:0,E=n?-1:1,h=e[t+c];for(c+=E,a=h&(1<<-l)-1,h>>=-l,l+=u;0>=-l,l+=r;0>1,E=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:a-1,A=r?1:-1,T=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(u=isNaN(t)?1:0,s=l):(s=Math.floor(Math.log(t)/Math.LN2),t*(o=Math.pow(2,-s))<1&&(s--,o*=2),2<=(t+=1<=s+c?E/o:E*Math.pow(2,1-c))*o&&(s++,o/=2),l<=s+c?(u=0,s=l):1<=s+c?(u=(t*o-1)*Math.pow(2,i),s+=c):(u=t*Math.pow(2,c-1)*Math.pow(2,i),s=0));8<=i;e[n+h]=255&u,h+=A,u/=256,i-=8);for(s=s<=kMaxLength())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+kMaxLength().toString(16)+" bytes");return 0|e}function internalIsBuffer(e){return!(null==e||!e._isBuffer)}function byteLength(e,t){if(internalIsBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return utf8ToBytes(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return base64ToBytes(e).length;default:if(r)return utf8ToBytes(e).length;t=(""+t).toLowerCase(),r=!0}}function slowToString(e,t,n){var r=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(t>>>=0))return"";for(e=e||"utf8";;)switch(e){case"hex":return hexSlice(this,t,n);case"utf8":case"utf-8":return utf8Slice(this,t,n);case"ascii":return asciiSlice(this,t,n);case"latin1":case"binary":return latin1Slice(this,t,n);case"base64":return base64Slice(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return utf16leSlice(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}function swap(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function bidirectionalIndexOf(e,t,n,r,i){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):2147483647=e.length){if(i)return-1;n=e.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof t&&(t=Buffer.from(t,r)),internalIsBuffer(t))return 0===t.length?-1:arrayIndexOf(e,t,n,r,i);if("number"==typeof t)return t&=255,Buffer.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):arrayIndexOf(e,[t],n,r,i);throw new TypeError("val must be string, number or Buffer")}function arrayIndexOf(e,t,n,r,i){var a,s=1,u=e.length,o=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;u/=s=2,o/=2,n/=2}function _(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(i){var l=-1;for(a=n;a>>10&1023|55296),l=56320|1023&l),r.push(l),i+=c}return decodeCodePointsArray(r)}Buffer.TYPED_ARRAY_SUPPORT=void 0===global$1.TYPED_ARRAY_SUPPORT||global$1.TYPED_ARRAY_SUPPORT,Buffer.poolSize=8192,Buffer._augment=function(e){return e.__proto__=Buffer.prototype,e},Buffer.from=function(e,t,n){return from(null,e,t,n)},Buffer.TYPED_ARRAY_SUPPORT&&(Buffer.prototype.__proto__=Uint8Array.prototype,Buffer.__proto__=Uint8Array),Buffer.alloc=function(e,t,n){return alloc(null,e,t,n)},Buffer.allocUnsafe=function(e){return allocUnsafe(null,e)},Buffer.allocUnsafeSlow=function(e){return allocUnsafe(null,e)},Buffer.isBuffer=isBuffer,Buffer.compare=function(e,t){if(!internalIsBuffer(e)||!internalIsBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var n=e.length,r=t.length,i=0,a=Math.min(n,r);it&&(e+=" ... ")),""},Buffer.prototype.compare=function(e,t,n,r,i){if(!internalIsBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),t<0||n>e.length||r<0||i>this.length)throw new RangeError("out of range index");if(i<=r&&n<=t)return 0;if(i<=r)return-1;if(n<=t)return 1;if(this===e)return 0;for(var a=(i>>>=0)-(r>>>=0),s=(n>>>=0)-(t>>>=0),u=Math.min(a,s),o=this.slice(r,i),_=e.slice(t,n),l=0;lthis.length)throw new RangeError("Attempt to write outside buffer bounds");r=r||"utf8";for(var a=!1;;)switch(r){case"hex":return hexWrite(this,e,t,n);case"utf8":case"utf-8":return utf8Write(this,e,t,n);case"ascii":return asciiWrite(this,e,t,n);case"latin1":case"binary":return latin1Write(this,e,t,n);case"base64":return base64Write(this,e,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ucs2Write(this,e,t,n);default:if(a)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),a=!0}},Buffer.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var MAX_ARGUMENTS_LENGTH=4096;function decodeCodePointsArray(e){var t=e.length;if(t<=MAX_ARGUMENTS_LENGTH)return String.fromCharCode.apply(String,e);for(var n="",r=0;re.length)throw new RangeError("Index out of range")}function objectWriteUInt16(e,t,n,r){t<0&&(t=65535+t+1);for(var i=0,a=Math.min(e.length-n,2);i>>8*(r?i:1-i)}function objectWriteUInt32(e,t,n,r){t<0&&(t=4294967295+t+1);for(var i=0,a=Math.min(e.length-n,4);i>>8*(r?i:3-i)&255}function checkIEEE754(e,t,n,r,i,a){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function writeFloat(e,t,n,r,i){return i||checkIEEE754(e,t,n,4),write(e,t,n,r,23,4),n+4}function writeDouble(e,t,n,r,i){return i||checkIEEE754(e,t,n,8),write(e,t,n,r,52,8),n+8}Buffer.prototype.slice=function(e,t){var n,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):r>>8):objectWriteUInt16(this,e,t,!0),t+2},Buffer.prototype.writeUInt16BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,2,65535,0),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):objectWriteUInt16(this,e,t,!1),t+2},Buffer.prototype.writeUInt32LE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,4294967295,0),Buffer.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):objectWriteUInt32(this,e,t,!0),t+4},Buffer.prototype.writeUInt32BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,4294967295,0),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):objectWriteUInt32(this,e,t,!1),t+4},Buffer.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);checkInt(this,e,t,n,i-1,-i)}var a=0,s=1,u=0;for(this[t]=255&e;++a>0)-u&255;return t+n},Buffer.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);checkInt(this,e,t,n,i-1,-i)}var a=n-1,s=1,u=0;for(this[t+a]=255&e;0<=--a&&(s*=256);)e<0&&0===u&&0!==this[t+a+1]&&(u=1),this[t+a]=(e/s>>0)-u&255;return t+n},Buffer.prototype.writeInt8=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,1,127,-128),Buffer.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},Buffer.prototype.writeInt16LE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,2,32767,-32768),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):objectWriteUInt16(this,e,t,!0),t+2},Buffer.prototype.writeInt16BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,2,32767,-32768),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):objectWriteUInt16(this,e,t,!1),t+2},Buffer.prototype.writeInt32LE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,2147483647,-2147483648),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):objectWriteUInt32(this,e,t,!0),t+4},Buffer.prototype.writeInt32BE=function(e,t,n){return e=+e,t|=0,n||checkInt(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),Buffer.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):objectWriteUInt32(this,e,t,!1),t+4},Buffer.prototype.writeFloatLE=function(e,t,n){return writeFloat(this,e,t,!0,n)},Buffer.prototype.writeFloatBE=function(e,t,n){return writeFloat(this,e,t,!1,n)},Buffer.prototype.writeDoubleLE=function(e,t,n){return writeDouble(this,e,t,!0,n)},Buffer.prototype.writeDoubleBE=function(e,t,n){return writeDouble(this,e,t,!1,n)},Buffer.prototype.copy=function(e,t,n,r){if(n=n||0,r||0===r||(r=this.length),t>=e.length&&(t=e.length),t=t||0,0=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t>>=0,n=void 0===n?this.length:n>>>0,"number"==typeof(e=e||0))for(a=t;a>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;a.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;a.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return a}function asciiToBytes(e){for(var t=[],n=0;n>8,i=n%256,a.push(i),a.push(r);return a}function base64ToBytes(e){return toByteArray(base64clean(e))}function blitBuffer(e,t,n,r){for(var i=0;i=t.length||i>=e.length);++i)t[i+n]=e[i];return i}function isnan(e){return e!=e}function isBuffer(e){return null!=e&&(!!e._isBuffer||isFastBuffer(e)||isSlowBuffer(e))}function isFastBuffer(e){return!!e.constructor&&"function"==typeof e.constructor.isBuffer&&e.constructor.isBuffer(e)}function isSlowBuffer(e){return"function"==typeof e.readFloatLE&&"function"==typeof e.slice&&isFastBuffer(e.slice(0,0))}var TextEncoder=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"encode",value:function(e){for(var t=e.length,n=-1,r=[],i=0,a=0,s=0;s!==t;){if(i=e.charCodeAt(s),s+=1,55296<=i&&i<=56319){if(s===t){r[n+=1]=239,r[n+=1]=191,r[n+=1]=189;break}if(!(56320<=(a=e.charCodeAt(s))&&a<=57343)){r[n+=1]=239,r[n+=1]=191,r[n+=1]=189;continue}if(s+=1,65535<(i=1024*(i-55296)+a-56320+65536)){r[n+=1]=240|i>>>18,r[n+=1]=128|i>>>12&63,r[n+=1]=128|i>>>6&63,r[n+=1]=128|63&i;continue}}i<=127?r[n+=1]=0|i:(i<=2047?r[n+=1]=192|i>>>6:(r[n+=1]=224|i>>>12,r[n+=1]=128|i>>>6&63),r[n+=1]=128|63&i)}return r.length=n+1,r}}]),e}(),JsonRpcMarshaller=function(){function e(){_classCallCheck(this,e)}return _createClass(e,null,[{key:"marshall",value:function(e){var t=null;try{var n=function e(t){var n=t.getParameters();for(var r in n)n[r]instanceof RpcStruct&&(n[r]=e(n[r]));return n}(e),r=JSON.stringify(n);t=this._encode(r)}catch(e){console.error("Failed to encode messages to JSON.",e)}return t}},{key:"unmarshall",value:function(e){var t=null;try{var n=this._decode(e);t=JSON.parse(n)}catch(e){console.error("Failed to parse JSON",e)}return t}},{key:"_encode",value:function(e){return new Uint8Array(TextEncoder.encode(e))}},{key:"_decode",value:function(e){return Buffer.from(e).toString()}}]),e}(),BinaryFrameHeader=function(){function _(e,t,n,r){_classCallCheck(this,_),this._rpcType=e,this._functionId=t,this._correlationId=n,this._jsonSize=r,this._bulkData=null,this._jsonData=null}return _createClass(_,[{key:"assembleHeaderBytes",value:function(){var e=[],t=this._functionId,n=this._correlationId;this._rpcType;e.push((251658240&t)>>24),e.push((16711680&t)>>16),e.push((65280&t)>>8),e.push(255&t),e.push((4278190080&n)>>24),e.push((16711680&n)>>16),e.push((65280&n)>>8),e.push(255&n);var r=this._jsonSize;return e.push((4278190080&r)>>24),e.push((16711680&r)>>16),e.push((65280&r)>>8),e.push(255&r),e}},{key:"setRpcType",value:function(e){return this._rpcType=e,this}},{key:"getRpcType",value:function(){return this._rpcType}},{key:"setFunctionId",value:function(e){return this._functionId=e,this}},{key:"getFunctionId",value:function(){return this._functionId}},{key:"setCorrelationId",value:function(e){return this._correlationId=e,this}},{key:"getCorrelationId",value:function(){return this._correlationId}},{key:"setJsonSize",value:function(e){return this._jsonSize=e,this}},{key:"getJsonSize",value:function(){return this._jsonSize}},{key:"getJsonData",value:function(){return this._jsonData}},{key:"setJsonData",value:function(e){return this._jsonData=e,this}},{key:"setBulkData",value:function(e){return this._bulkData=e,this}},{key:"getBulkData",value:function(){return this._bulkData}}],[{key:"fromBinaryHeader",value:function(e){var t=e[0]>>4,n=(15&e[0])<<24;n+=(255&e[1])<<16,n+=(255&e[2])<<8,n+=255&e[3];var r=(255&e[4])<<24;r+=(255&e[5])<<16,r+=(255&e[6])<<8,r+=255&e[7];var i=(255&e[8])<<24;i+=(255&e[9])<<16,i+=(255&e[10])<<8;var a=new _(t,n,r,i+=255&e[11]),s=_.HEADER_SIZE,u=_.HEADER_SIZE+i;if(a.setJsonData(e.slice(s,u)),e.length>u){var o=e.slice(u);a.setBulkData(o)}return a}}]),_}();BinaryFrameHeader.HEADER_SIZE=12;var MessageFrameDisassembler=function(){function o(e,t,n,r,i,a,s){if(_classCallCheck(this,o),this._rpcRequest=e,this._sessionId=t,this._messageId=n,this._isEncrypted=a,!r)throw new Error("MTU must be specified.");if(this._mtu=r,!i)throw new Error("Version must be specified.");this._version=i,this._packetCallback=s}return _createClass(o,[{key:"_buildRPCMainBuffer",value:function(){var e=this._rpcRequest.getBulkData(),t=this._rpcRequest.getCorrelationId(),n=this._rpcRequest.getRPCType(),r=this._rpcRequest.getFunctionName(),i=FunctionID.valueForKey(r);if(!i)throw new Error("Failed to find function ".concat(r));var a=JsonRpcMarshaller.marshall(this._rpcRequest),s=a.length,u=new BinaryFrameHeader(n,i,t);u.setJsonData(a),u.setJsonSize(s),u.setBulkData(e);var o=u.getBulkData(),_=0;o&&(_=o.length);var l=new Uint8Array(12+s+_);return l.set(u.assembleHeaderBytes(),0),l.set(a,12),o&&l.set(o,12+s),l}},{key:"_doRequest",value:function(){var e=this._version,t=FrameType.SINGLE,n=SdlPacket.SERVICE_TYPE_RPC,r=this._sessionId,i=this._messageId,a=this._isEncrypted,s=this._buildRPCMainBuffer(),u=this._mtu,o=Math.ceil(s.length/u);if(o<=1){var _=this._constructPacket(e,n,0,r,i,t,s,a);this._packetCallback(_)}else{var l=new ArrayBuffer(8),c=new DataView(l);c.setUint32(0,s.length,!1),c.setUint32(4,o,!1);var E=new Uint8Array(l),h=this._constructPacket(e,n,0,r,i,FrameType.FIRST,E,a);this._packetCallback(h),this._buildConsecutiveFrames(e,n,r,i,s,u,a)}}},{key:"_constructPacket",value:function(e,t,n,r,i,a,s,u){var o=s.length;return new SdlPacket(e,u,a,t,n,r,o,i,s,0,o)}},{key:"_buildConsecutiveFrames",value:function(e,t,n,r,i,a,s){for(var u,o=0,_=0;0!==u;){u=_+a>=i.length?0:o%255+1;var l=this._constructPacket(e,t,u,n,r,FrameType.CONSECUTIVE,i.slice(_,_+a),s);this._packetCallback(l),o++,_+=a}}}],[{key:"buildRPC",value:function(e,t,n,r,i,a,s){var u=new o(e,t,n,r,i,a,s);return u._doRequest(),u}}]),o}(),TransportListener=function(){function e(){_classCallCheck(this,e),this._onTransportConnected=null,this._onTransportDisconnected=null,this._onError=null,this._onPacketReceived=null}return _createClass(e,[{key:"setOnTransportConnected",value:function(e){return this._onTransportConnected=e,this}},{key:"setOnTransportDisconnected",value:function(e){return this._onTransportDisconnected=e,this}},{key:"setOnError",value:function(e){return this._onError=e,this}},{key:"setOnPacketReceived",value:function(e){return this._onPacketReceived=e,this}},{key:"onTransportConnected",value:function(){"function"==typeof this._onTransportConnected&&this._onTransportConnected()}},{key:"onTransportDisconnected",value:function(){"function"==typeof this._onTransportDisconnected&&this._onTransportDisconnected()}},{key:"onError",value:function(e){var t=0e.getMajor())return 1;if(this.getMajor()===e.getMajor()){if(this.getMinor()>e.getMinor())return 1;if(this.getMinor()===e.getMinor()){if(this.getPatch()>e.getPatch())return 1;if(this.getPatch()===e.getPatch())return 0}}return-1}}]),r}(),ServiceType=function(){function t(){return _classCallCheck(this,t),_possibleConstructorReturn(this,_getPrototypeOf(t).call(this))}return _inherits(t,Enum),_createClass(t,null,[{key:"valueForKey",value:function(e){return t._valueForKey(e,t._MAP)}},{key:"keyForValue",value:function(e){return t._keyForValue(e,t._MAP)}},{key:"CONTROL",get:function(){return t._MAP.CONTROL}},{key:"RPC",get:function(){return t._MAP.RPC}},{key:"AUDIO",get:function(){return t._MAP.AUDIO}},{key:"VIDEO",get:function(){return t._MAP.VIDEO}},{key:"HYBRID",get:function(){return t._MAP.HYBRID}}]),t}();ServiceType._MAP=Object.freeze({CONTROL:0,RPC:7,AUDIO:10,VIDEO:11,HYBRID:15});var MessageFrameAssembler=function(){function t(e){if(_classCallCheck(this,t),"function"!=typeof e)throw new Error("Callback not of expected type (function) for MessageFrameAssembler");this._callback=e,this._accumulator=[],this._totalConsecutiveFrames=0,this._consecutiveFramesHandledCount=0,this._consecutiveFramesDataLength=0}return _createClass(t,[{key:"handleFrame",value:function(e){var t=e.getFrameType();return t!==FrameType.FIRST&&t!==FrameType.CONSECUTIVE?this._callback(null,e):this._handleMultiFrameMessage(e)}},{key:"_handleFirstDataFrame",value:function(e){var t=e.getPayload();if(t instanceof Uint8Array!=!0||8!==t.length)throw new Error("Error handling first frame. Payload is an invalid length should be length 8.");for(var n in t)if(n<0||255>4,0===this._version?n.ERROR_STATE:(this._encryption=1==(e&n.ENCRYPTION_MASK)>>3,this._frameType=e&n.FRAME_TYPE_MASK,(this._version<1||5FrameType.CONSECUTIVE?n.ERROR_STATE:n.SERVICE_TYPE_STATE);if(t===n.SERVICE_TYPE_STATE)return this._serviceType=255&e,n.CONTROL_FRAME_INFO_STATE;if(t===n.CONTROL_FRAME_INFO_STATE){switch(this._controlFrameInfo=255&e,this._frameType){case FrameType.CONTROL:break;case FrameType.SINGLE:case FrameType.FIRST:if(0!==this._controlFrameInfo)return n.ERROR_STATE;break;case FrameType.CONSECUTIVE:break;default:return n.ERROR_STATE}return n.SESSION_ID_STATE}if(t===n.SESSION_ID_STATE)return this._sessionID=255&e,n.DATA_SIZE_1_STATE;if(t===n.DATA_SIZE_1_STATE)return this._dataLength+=(255&e)<<24,n.DATA_SIZE_2_STATE;if(t===n.DATA_SIZE_2_STATE)return this._dataLength+=(255&e)<<16,n.DATA_SIZE_3_STATE;if(t===n.DATA_SIZE_3_STATE)return this._dataLength+=(255&e)<<8,n.DATA_SIZE_4_STATE;if(t!==n.DATA_SIZE_4_STATE)return t===n.MESSAGE_1_STATE?(this._messageID+=(255&e)<<24,n.MESSAGE_2_STATE):t===n.MESSAGE_2_STATE?(this._messageID+=(255&e)<<16,n.MESSAGE_3_STATE):t===n.MESSAGE_3_STATE?(this._messageID+=(255&e)<<8,n.MESSAGE_4_STATE):t===n.MESSAGE_4_STATE?(this._messageID+=255&e,0===this._dataLength?n.FINISHED_STATE:(this._dumpSize=this._dataLength,this._payload=new Uint8Array(this._dataLength),n.DATA_PUMP_STATE)):t===n.DATA_PUMP_STATE?(this._payload[this._dataLength-this._dumpSize]=e,this._dumpSize-=1,0mediaClock) + * @return {String} + */ + static get CLEAR () { + return UpdateMode._MAP.CLEAR; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return UpdateMode._valueForKey(key, UpdateMode._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return UpdateMode._keyForValue(value, UpdateMode._MAP); + } +} + +UpdateMode._MAP = Object.freeze({ + 'COUNTUP': 'COUNTUP', + 'COUNTDOWN': 'COUNTDOWN', + 'PAUSE': 'PAUSE', + 'RESUME': 'RESUME', + 'CLEAR': 'CLEAR', +}); + +export { UpdateMode }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VehicleDataActiveStatus.js b/lib/js/src/rpc/enums/VehicleDataActiveStatus.js new file mode 100644 index 00000000..be9cf47a --- /dev/null +++ b/lib/js/src/rpc/enums/VehicleDataActiveStatus.js @@ -0,0 +1,111 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Reflects the status of given vehicle component. + * @typedef {Enum} VehicleDataActiveStatus + * @property {Object} _MAP + */ +class VehicleDataActiveStatus extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get VDAS_INACTIVE_NOT_CONFIRMED () { + return VehicleDataActiveStatus._MAP.VDAS_INACTIVE_NOT_CONFIRMED; + } + + /** + * @return {String} + */ + static get VDAS_INACTIVE_CONFIRMED () { + return VehicleDataActiveStatus._MAP.VDAS_INACTIVE_CONFIRMED; + } + + /** + * @return {String} + */ + static get VDAS_ACTIVE_NOT_CONFIRMED () { + return VehicleDataActiveStatus._MAP.VDAS_ACTIVE_NOT_CONFIRMED; + } + + /** + * @return {String} + */ + static get VDAS_ACTIVE_CONFIRMED () { + return VehicleDataActiveStatus._MAP.VDAS_ACTIVE_CONFIRMED; + } + + /** + * @return {String} + */ + static get VDAS_FAULT () { + return VehicleDataActiveStatus._MAP.VDAS_FAULT; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VehicleDataActiveStatus._valueForKey(key, VehicleDataActiveStatus._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VehicleDataActiveStatus._keyForValue(value, VehicleDataActiveStatus._MAP); + } +} + +VehicleDataActiveStatus._MAP = Object.freeze({ + 'VDAS_INACTIVE_NOT_CONFIRMED': 'INACTIVE_NOT_CONFIRMED', + 'VDAS_INACTIVE_CONFIRMED': 'INACTIVE_CONFIRMED', + 'VDAS_ACTIVE_NOT_CONFIRMED': 'ACTIVE_NOT_CONFIRMED', + 'VDAS_ACTIVE_CONFIRMED': 'ACTIVE_CONFIRMED', + 'VDAS_FAULT': 'FAULT', +}); + +export { VehicleDataActiveStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VehicleDataEventStatus.js b/lib/js/src/rpc/enums/VehicleDataEventStatus.js new file mode 100644 index 00000000..0cb39425 --- /dev/null +++ b/lib/js/src/rpc/enums/VehicleDataEventStatus.js @@ -0,0 +1,111 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Reflects the status of a vehicle data event; e.g. a seat belt event status. + * @typedef {Enum} VehicleDataEventStatus + * @property {Object} _MAP + */ +class VehicleDataEventStatus extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get VDES_NO_EVENT () { + return VehicleDataEventStatus._MAP.VDES_NO_EVENT; + } + + /** + * @return {String} + */ + static get VDES_NO () { + return VehicleDataEventStatus._MAP.VDES_NO; + } + + /** + * @return {String} + */ + static get VDES_YES () { + return VehicleDataEventStatus._MAP.VDES_YES; + } + + /** + * @return {String} + */ + static get VDES_NOT_SUPPORTED () { + return VehicleDataEventStatus._MAP.VDES_NOT_SUPPORTED; + } + + /** + * @return {String} + */ + static get VDES_FAULT () { + return VehicleDataEventStatus._MAP.VDES_FAULT; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VehicleDataEventStatus._valueForKey(key, VehicleDataEventStatus._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VehicleDataEventStatus._keyForValue(value, VehicleDataEventStatus._MAP); + } +} + +VehicleDataEventStatus._MAP = Object.freeze({ + 'VDES_NO_EVENT': 'NO_EVENT', + 'VDES_NO': 'NO', + 'VDES_YES': 'YES', + 'VDES_NOT_SUPPORTED': 'NOT_SUPPORTED', + 'VDES_FAULT': 'FAULT', +}); + +export { VehicleDataEventStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VehicleDataNotificationStatus.js b/lib/js/src/rpc/enums/VehicleDataNotificationStatus.js new file mode 100644 index 00000000..fa5f1eee --- /dev/null +++ b/lib/js/src/rpc/enums/VehicleDataNotificationStatus.js @@ -0,0 +1,103 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Reflects the status of a vehicle data notification. + * @typedef {Enum} VehicleDataNotificationStatus + * @property {Object} _MAP + */ +class VehicleDataNotificationStatus extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get VDNS_NOT_SUPPORTED () { + return VehicleDataNotificationStatus._MAP.VDNS_NOT_SUPPORTED; + } + + /** + * @return {String} + */ + static get VDNS_NORMAL () { + return VehicleDataNotificationStatus._MAP.VDNS_NORMAL; + } + + /** + * @return {String} + */ + static get VDNS_ACTIVE () { + return VehicleDataNotificationStatus._MAP.VDNS_ACTIVE; + } + + /** + * @return {String} + */ + static get VDNS_NOT_USED () { + return VehicleDataNotificationStatus._MAP.VDNS_NOT_USED; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VehicleDataNotificationStatus._valueForKey(key, VehicleDataNotificationStatus._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VehicleDataNotificationStatus._keyForValue(value, VehicleDataNotificationStatus._MAP); + } +} + +VehicleDataNotificationStatus._MAP = Object.freeze({ + 'VDNS_NOT_SUPPORTED': 'NOT_SUPPORTED', + 'VDNS_NORMAL': 'NORMAL', + 'VDNS_ACTIVE': 'ACTIVE', + 'VDNS_NOT_USED': 'NOT_USED', +}); + +export { VehicleDataNotificationStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VehicleDataResultCode.js b/lib/js/src/rpc/enums/VehicleDataResultCode.js new file mode 100644 index 00000000..3b5e6bb5 --- /dev/null +++ b/lib/js/src/rpc/enums/VehicleDataResultCode.js @@ -0,0 +1,152 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Enumeration that describes possible result codes of a vehicle data entry request. + * @typedef {Enum} VehicleDataResultCode + * @property {Object} _MAP + */ +class VehicleDataResultCode extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * Individual vehicle data item / DTC / DID request or subscription successful + * @return {String} + */ + static get VDRC_SUCCESS () { + return VehicleDataResultCode._MAP.VDRC_SUCCESS; + } + + /** + * DTC / DID request successful, however, not all active DTCs or full contents of DID location available + * @return {String} + */ + static get VDRC_TRUNCATED_DATA () { + return VehicleDataResultCode._MAP.VDRC_TRUNCATED_DATA; + } + + /** + * This vehicle data item is not allowed for this app by the OEM/Manufactorer of the connected module. + * @return {String} + */ + static get VDRC_DISALLOWED () { + return VehicleDataResultCode._MAP.VDRC_DISALLOWED; + } + + /** + * The user has not granted access to this type of vehicle data item at this time. + * @return {String} + */ + static get VDRC_USER_DISALLOWED () { + return VehicleDataResultCode._MAP.VDRC_USER_DISALLOWED; + } + + /** + * The ECU ID referenced is not a valid ID on the bus / system. + * @return {String} + */ + static get VDRC_INVALID_ID () { + return VehicleDataResultCode._MAP.VDRC_INVALID_ID; + } + + /** + * The requested vehicle data item / DTC / DID is not currently available or responding on the bus / system. + * @return {String} + */ + static get VDRC_DATA_NOT_AVAILABLE () { + return VehicleDataResultCode._MAP.VDRC_DATA_NOT_AVAILABLE; + } + + /** + * The vehicle data item is already subscribed. + * @return {String} + */ + static get VDRC_DATA_ALREADY_SUBSCRIBED () { + return VehicleDataResultCode._MAP.VDRC_DATA_ALREADY_SUBSCRIBED; + } + + /** + * The vehicle data item cannot be unsubscribed because it is not currently subscribed. + * @return {String} + */ + static get VDRC_DATA_NOT_SUBSCRIBED () { + return VehicleDataResultCode._MAP.VDRC_DATA_NOT_SUBSCRIBED; + } + + /** + * The request for this item is ignored because it is already in progress. + * @return {String} + */ + static get VDRC_IGNORED () { + return VehicleDataResultCode._MAP.VDRC_IGNORED; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VehicleDataResultCode._valueForKey(key, VehicleDataResultCode._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VehicleDataResultCode._keyForValue(value, VehicleDataResultCode._MAP); + } +} + +VehicleDataResultCode._MAP = Object.freeze({ + 'VDRC_SUCCESS': 'SUCCESS', + 'VDRC_TRUNCATED_DATA': 'TRUNCATED_DATA', + 'VDRC_DISALLOWED': 'DISALLOWED', + 'VDRC_USER_DISALLOWED': 'USER_DISALLOWED', + 'VDRC_INVALID_ID': 'INVALID_ID', + 'VDRC_DATA_NOT_AVAILABLE': 'VEHICLE_DATA_NOT_AVAILABLE', + 'VDRC_DATA_ALREADY_SUBSCRIBED': 'DATA_ALREADY_SUBSCRIBED', + 'VDRC_DATA_NOT_SUBSCRIBED': 'DATA_NOT_SUBSCRIBED', + 'VDRC_IGNORED': 'IGNORED', +}); + +export { VehicleDataResultCode }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VehicleDataStatus.js b/lib/js/src/rpc/enums/VehicleDataStatus.js new file mode 100644 index 00000000..54733f79 --- /dev/null +++ b/lib/js/src/rpc/enums/VehicleDataStatus.js @@ -0,0 +1,95 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Reflects the status of a binary vehicle data item. + * @typedef {Enum} VehicleDataStatus + * @property {Object} _MAP + */ +class VehicleDataStatus extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get VDS_NO_DATA_EXISTS () { + return VehicleDataStatus._MAP.VDS_NO_DATA_EXISTS; + } + + /** + * @return {String} + */ + static get VDS_OFF () { + return VehicleDataStatus._MAP.VDS_OFF; + } + + /** + * @return {String} + */ + static get VDS_ON () { + return VehicleDataStatus._MAP.VDS_ON; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VehicleDataStatus._valueForKey(key, VehicleDataStatus._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VehicleDataStatus._keyForValue(value, VehicleDataStatus._MAP); + } +} + +VehicleDataStatus._MAP = Object.freeze({ + 'VDS_NO_DATA_EXISTS': 'NO_DATA_EXISTS', + 'VDS_OFF': 'OFF', + 'VDS_ON': 'ON', +}); + +export { VehicleDataStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VehicleDataType.js b/lib/js/src/rpc/enums/VehicleDataType.js new file mode 100644 index 00000000..96c1345c --- /dev/null +++ b/lib/js/src/rpc/enums/VehicleDataType.js @@ -0,0 +1,328 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Defines the data types that can be published and subscribed to. + * @typedef {Enum} VehicleDataType + * @property {Object} _MAP + */ +class VehicleDataType extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * Notifies GPSData may be subscribed + * @return {String} + */ + static get VEHICLEDATA_GPS () { + return VehicleDataType._MAP.VEHICLEDATA_GPS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_SPEED () { + return VehicleDataType._MAP.VEHICLEDATA_SPEED; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_RPM () { + return VehicleDataType._MAP.VEHICLEDATA_RPM; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_FUELLEVEL () { + return VehicleDataType._MAP.VEHICLEDATA_FUELLEVEL; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_FUELLEVEL_STATE () { + return VehicleDataType._MAP.VEHICLEDATA_FUELLEVEL_STATE; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_FUELCONSUMPTION () { + return VehicleDataType._MAP.VEHICLEDATA_FUELCONSUMPTION; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_EXTERNTEMP () { + return VehicleDataType._MAP.VEHICLEDATA_EXTERNTEMP; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_VIN () { + return VehicleDataType._MAP.VEHICLEDATA_VIN; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_PRNDL () { + return VehicleDataType._MAP.VEHICLEDATA_PRNDL; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_TIREPRESSURE () { + return VehicleDataType._MAP.VEHICLEDATA_TIREPRESSURE; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_ODOMETER () { + return VehicleDataType._MAP.VEHICLEDATA_ODOMETER; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_BELTSTATUS () { + return VehicleDataType._MAP.VEHICLEDATA_BELTSTATUS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_BODYINFO () { + return VehicleDataType._MAP.VEHICLEDATA_BODYINFO; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_DEVICESTATUS () { + return VehicleDataType._MAP.VEHICLEDATA_DEVICESTATUS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_ECALLINFO () { + return VehicleDataType._MAP.VEHICLEDATA_ECALLINFO; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_AIRBAGSTATUS () { + return VehicleDataType._MAP.VEHICLEDATA_AIRBAGSTATUS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_EMERGENCYEVENT () { + return VehicleDataType._MAP.VEHICLEDATA_EMERGENCYEVENT; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_CLUSTERMODESTATUS () { + return VehicleDataType._MAP.VEHICLEDATA_CLUSTERMODESTATUS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_MYKEY () { + return VehicleDataType._MAP.VEHICLEDATA_MYKEY; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_BRAKING () { + return VehicleDataType._MAP.VEHICLEDATA_BRAKING; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_WIPERSTATUS () { + return VehicleDataType._MAP.VEHICLEDATA_WIPERSTATUS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_HEADLAMPSTATUS () { + return VehicleDataType._MAP.VEHICLEDATA_HEADLAMPSTATUS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_BATTVOLTAGE () { + return VehicleDataType._MAP.VEHICLEDATA_BATTVOLTAGE; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_ENGINETORQUE () { + return VehicleDataType._MAP.VEHICLEDATA_ENGINETORQUE; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_ACCPEDAL () { + return VehicleDataType._MAP.VEHICLEDATA_ACCPEDAL; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_STEERINGWHEEL () { + return VehicleDataType._MAP.VEHICLEDATA_STEERINGWHEEL; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_TURNSIGNAL () { + return VehicleDataType._MAP.VEHICLEDATA_TURNSIGNAL; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_FUELRANGE () { + return VehicleDataType._MAP.VEHICLEDATA_FUELRANGE; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_ENGINEOILLIFE () { + return VehicleDataType._MAP.VEHICLEDATA_ENGINEOILLIFE; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_ELECTRONICPARKBRAKESTATUS () { + return VehicleDataType._MAP.VEHICLEDATA_ELECTRONICPARKBRAKESTATUS; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_CLOUDAPPVEHICLEID () { + return VehicleDataType._MAP.VEHICLEDATA_CLOUDAPPVEHICLEID; + } + + /** + * @return {String} + */ + static get VEHICLEDATA_OEM_CUSTOM_DATA () { + return VehicleDataType._MAP.VEHICLEDATA_OEM_CUSTOM_DATA; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VehicleDataType._valueForKey(key, VehicleDataType._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VehicleDataType._keyForValue(value, VehicleDataType._MAP); + } +} + +VehicleDataType._MAP = Object.freeze({ + 'VEHICLEDATA_GPS': 'VEHICLEDATA_GPS', + 'VEHICLEDATA_SPEED': 'VEHICLEDATA_SPEED', + 'VEHICLEDATA_RPM': 'VEHICLEDATA_RPM', + 'VEHICLEDATA_FUELLEVEL': 'VEHICLEDATA_FUELLEVEL', + 'VEHICLEDATA_FUELLEVEL_STATE': 'VEHICLEDATA_FUELLEVEL_STATE', + 'VEHICLEDATA_FUELCONSUMPTION': 'VEHICLEDATA_FUELCONSUMPTION', + 'VEHICLEDATA_EXTERNTEMP': 'VEHICLEDATA_EXTERNTEMP', + 'VEHICLEDATA_VIN': 'VEHICLEDATA_VIN', + 'VEHICLEDATA_PRNDL': 'VEHICLEDATA_PRNDL', + 'VEHICLEDATA_TIREPRESSURE': 'VEHICLEDATA_TIREPRESSURE', + 'VEHICLEDATA_ODOMETER': 'VEHICLEDATA_ODOMETER', + 'VEHICLEDATA_BELTSTATUS': 'VEHICLEDATA_BELTSTATUS', + 'VEHICLEDATA_BODYINFO': 'VEHICLEDATA_BODYINFO', + 'VEHICLEDATA_DEVICESTATUS': 'VEHICLEDATA_DEVICESTATUS', + 'VEHICLEDATA_ECALLINFO': 'VEHICLEDATA_ECALLINFO', + 'VEHICLEDATA_AIRBAGSTATUS': 'VEHICLEDATA_AIRBAGSTATUS', + 'VEHICLEDATA_EMERGENCYEVENT': 'VEHICLEDATA_EMERGENCYEVENT', + 'VEHICLEDATA_CLUSTERMODESTATUS': 'VEHICLEDATA_CLUSTERMODESTATUS', + 'VEHICLEDATA_MYKEY': 'VEHICLEDATA_MYKEY', + 'VEHICLEDATA_BRAKING': 'VEHICLEDATA_BRAKING', + 'VEHICLEDATA_WIPERSTATUS': 'VEHICLEDATA_WIPERSTATUS', + 'VEHICLEDATA_HEADLAMPSTATUS': 'VEHICLEDATA_HEADLAMPSTATUS', + 'VEHICLEDATA_BATTVOLTAGE': 'VEHICLEDATA_BATTVOLTAGE', + 'VEHICLEDATA_ENGINETORQUE': 'VEHICLEDATA_ENGINETORQUE', + 'VEHICLEDATA_ACCPEDAL': 'VEHICLEDATA_ACCPEDAL', + 'VEHICLEDATA_STEERINGWHEEL': 'VEHICLEDATA_STEERINGWHEEL', + 'VEHICLEDATA_TURNSIGNAL': 'VEHICLEDATA_TURNSIGNAL', + 'VEHICLEDATA_FUELRANGE': 'VEHICLEDATA_FUELRANGE', + 'VEHICLEDATA_ENGINEOILLIFE': 'VEHICLEDATA_ENGINEOILLIFE', + 'VEHICLEDATA_ELECTRONICPARKBRAKESTATUS': 'VEHICLEDATA_ELECTRONICPARKBRAKESTATUS', + 'VEHICLEDATA_CLOUDAPPVEHICLEID': 'VEHICLEDATA_CLOUDAPPVEHICLEID', + 'VEHICLEDATA_OEM_CUSTOM_DATA': 'VEHICLEDATA_OEM_CUSTOM_DATA', +}); + +export { VehicleDataType }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VentilationMode.js b/lib/js/src/rpc/enums/VentilationMode.js new file mode 100644 index 00000000..fa2d72eb --- /dev/null +++ b/lib/js/src/rpc/enums/VentilationMode.js @@ -0,0 +1,102 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * @typedef {Enum} VentilationMode + * @property {Object} _MAP + */ +class VentilationMode extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get UPPER () { + return VentilationMode._MAP.UPPER; + } + + /** + * @return {String} + */ + static get LOWER () { + return VentilationMode._MAP.LOWER; + } + + /** + * @return {String} + */ + static get BOTH () { + return VentilationMode._MAP.BOTH; + } + + /** + * @return {String} + */ + static get NONE () { + return VentilationMode._MAP.NONE; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return VentilationMode._valueForKey(key, VentilationMode._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return VentilationMode._keyForValue(value, VentilationMode._MAP); + } +} + +VentilationMode._MAP = Object.freeze({ + 'UPPER': 'UPPER', + 'LOWER': 'LOWER', + 'BOTH': 'BOTH', + 'NONE': 'NONE', +}); + +export { VentilationMode }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VideoStreamingCodec.js b/lib/js/src/rpc/enums/VideoStreamingCodec.js index 81005805..020099a1 100644 --- a/lib/js/src/rpc/enums/VideoStreamingCodec.js +++ b/lib/js/src/rpc/enums/VideoStreamingCodec.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,17 +34,21 @@ import { Enum } from '../../util/Enum.js'; /** + * Enum for each type of video streaming codec. * @typedef {Enum} VideoStreamingCodec * @property {Object} _MAP */ class VideoStreamingCodec extends Enum { /** - * @constructor - */ + * @constructor + */ constructor () { super(); } + /** + * A block-oriented motion-compensation-based video compression standard. As of 2014 it is one of the most + * commonly used formats for the recording, compression, and distribution of video content. * @return {String} */ static get H264 () { @@ -51,6 +56,10 @@ class VideoStreamingCodec extends Enum { } /** + * High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video compression standard, + * one of several potential successors to the widely used AVC (H.264 or MPEG-4 Part 10). In comparison to AVC, + * HEVC offers about double the data compression ratio at the same level of video quality, or substantially + * improved video quality at the same bit rate. It supports resolutions up to 8192x4320, including 8K UHD. * @return {String} */ static get H265 () { @@ -58,6 +67,10 @@ class VideoStreamingCodec extends Enum { } /** + * Theora is derived from the formerly proprietary VP3 codec, released into the public domain by On2 Technologies. + * It is broadly comparable in design and bitrate efficiency to MPEG-4 Part 2, early versions of Windows Media + * Video, and RealVideo while lacking some of the features present in some of these other codecs. It is comparable + * in open standards philosophy to the BBC's Dirac codec. * @return {String} */ static get Theora () { @@ -65,6 +78,9 @@ class VideoStreamingCodec extends Enum { } /** + * VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and Opus audio. The + * image format WebP is based on VP8's intra-frame coding. VP8's direct successor, VP9, and the emerging royalty- + * free internet video format AV1 from the Alliance for Open Media (AOMedia) are based on VP8. * @return {String} */ static get VP8 () { @@ -72,6 +88,8 @@ class VideoStreamingCodec extends Enum { } /** + * Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video (UHD) and also enables + * lossless compression. * @return {String} */ static get VP9 () { @@ -79,58 +97,29 @@ class VideoStreamingCodec extends Enum { } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey (key) { return VideoStreamingCodec._valueForKey(key, VideoStreamingCodec._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue (value) { return VideoStreamingCodec._keyForValue(value, VideoStreamingCodec._MAP); } } VideoStreamingCodec._MAP = Object.freeze({ - /** - * A block-oriented motion-compensation-based video compression standard. As of 2014 it is one - * of the most commonly used formats for the recording, compression, and distribution of video - * content. - */ 'H264': 'H264', - /** - * High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video - * compression standard, one of several potential successors to the widely used AVC - * (H.264 or MPEG-4 Part 10). In comparison to AVC, HEVC offers about double the data - * compression ratio at the same level of video quality, or substantially improved video quality - * at the same bit rate. It supports resolutions up to 8192x4320, including 8K UHD. - */ 'H265': 'H265', - /** - * Theora is derived from the formerly proprietary VP3 codec, released into the public domain by - * On2 Technologies. It is broadly comparable in design and bitrate efficiency to MPEG-4 Part 2, - * early versions of Windows Media Video, and RealVideo while lacking some of the features - * present in some of these other codecs. It is comparable in open standards philosophy to the - * BBC's Dirac codec. - */ 'Theora': 'Theora', - /** - * VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and - * Opus audio. The image format WebP is based on VP8's intra-frame coding. VP8's direct - * successor, VP9, and the emerging royalty-free internet video format AV1 from the Alliance - * for Open Media (AOMedia) are based on VP8. - */ 'VP8': 'VP8', - /** - * Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video - * (UHD) and also enables lossless compression. - */ 'VP9': 'VP9', }); diff --git a/lib/js/src/rpc/enums/VideoStreamingProtocol.js b/lib/js/src/rpc/enums/VideoStreamingProtocol.js index 018e1f5a..92da2d22 100644 --- a/lib/js/src/rpc/enums/VideoStreamingProtocol.js +++ b/lib/js/src/rpc/enums/VideoStreamingProtocol.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,17 +34,20 @@ import { Enum } from '../../util/Enum.js'; /** + * Enum for each type of video streaming protocol type. * @typedef {Enum} VideoStreamingProtocol * @property {Object} _MAP */ class VideoStreamingProtocol extends Enum { /** - * @constructor - */ + * @constructor + */ constructor () { super(); } + /** + * Raw stream bytes that contains no timestamp data and is the lowest supported video streaming * @return {String} */ static get RAW () { @@ -51,6 +55,9 @@ class VideoStreamingProtocol extends Enum { } /** + * RTP facilitates the transfer of real-time data. Information provided by this protocol include timestamps (for + * synchronization), sequence numbers (for packet loss and reordering detection) and the payload format which + * indicates the encoded format of the data. * @return {String} */ static get RTP () { @@ -58,6 +65,9 @@ class VideoStreamingProtocol extends Enum { } /** + * The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the Real-time Transport + * Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP) for media stream delivery. However, some + * vendors implement proprietary transport protocols. * @return {String} */ static get RTSP () { @@ -65,6 +75,9 @@ class VideoStreamingProtocol extends Enum { } /** + * Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by Macromedia for streaming + * audio, video and data over the Internet, between a Flash player and a server. Macromedia is now owned by Adobe, + * which has released an incomplete version of the specification of the protocol for public use. * @return {String} */ static get RTMP () { @@ -72,6 +85,8 @@ class VideoStreamingProtocol extends Enum { } /** + * The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and Vorbis audio + * streams. In 2013 it was updated to accommodate VP9 video and Opus audio. * @return {String} */ static get WEBM () { @@ -79,54 +94,30 @@ class VideoStreamingProtocol extends Enum { } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey (key) { return VideoStreamingProtocol._valueForKey(key, VideoStreamingProtocol._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue (value) { return VideoStreamingProtocol._keyForValue(value, VideoStreamingProtocol._MAP); } } VideoStreamingProtocol._MAP = Object.freeze({ - /** - * Raw stream bytes that contains no timestamp data and is the lowest supported video streaming - */ 'RAW': 'RAW', - /** - * RTP facilitates the transfer of real-time data. Information provided by this protocol include - * timestamps (for synchronization), sequence numbers (for packet loss and reordering detection) - * and the payload format which indicates the encoded format of the data. - */ 'RTP': 'RTP', - /** - * The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the - * Real-time Transport Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP) for - * media stream delivery. However, some vendors implement proprietary transport protocols. - */ 'RTSP': 'RTSP', - /** - * Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by - * Macromedia for streaming audio, video and data over the Internet, between a Flash player and - * a server. Macromedia is now owned by Adobe, which has released an incomplete version of the - * specification of the protocol for public use. - */ 'RTMP': 'RTMP', - /** - * The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and - * Vorbis audio streams. In 2013 it was updated to accommodate VP9 video and Opus audio. - */ 'WEBM': 'WEBM', - }); export { VideoStreamingProtocol }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VideoStreamingState.js b/lib/js/src/rpc/enums/VideoStreamingState.js index 73a95092..75ebbcd0 100644 --- a/lib/js/src/rpc/enums/VideoStreamingState.js +++ b/lib/js/src/rpc/enums/VideoStreamingState.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,10 +34,14 @@ import { Enum } from '../../util/Enum.js'; /** + * Enumeration that describes possible states of video streaming. * @typedef {Enum} VideoStreamingState * @property {Object} _MAP */ class VideoStreamingState extends Enum { + /** + * @constructor + */ constructor () { super(); } @@ -56,19 +61,19 @@ class VideoStreamingState extends Enum { } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey (key) { return VideoStreamingState._valueForKey(key, VideoStreamingState._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue (value) { return VideoStreamingState._keyForValue(value, VideoStreamingState._MAP); } @@ -77,7 +82,6 @@ class VideoStreamingState extends Enum { VideoStreamingState._MAP = Object.freeze({ 'STREAMABLE': 'STREAMABLE', 'NOT_STREAMABLE': 'NOT_STREAMABLE', - }); export { VideoStreamingState }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/VrCapabilities.js b/lib/js/src/rpc/enums/VrCapabilities.js index 03aeed02..08ead2d6 100644 --- a/lib/js/src/rpc/enums/VrCapabilities.js +++ b/lib/js/src/rpc/enums/VrCapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,10 +34,14 @@ import { Enum } from '../../util/Enum.js'; /** + * Contains information about the VR capabilities. * @typedef {Enum} VrCapabilities * @property {Object} _MAP */ class VrCapabilities extends Enum { + /** + * @constructor + */ constructor () { super(); } @@ -49,19 +54,19 @@ class VrCapabilities extends Enum { } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey (key) { return VrCapabilities._valueForKey(key, VrCapabilities._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue (value) { return VrCapabilities._keyForValue(value, VrCapabilities._MAP); } diff --git a/lib/js/src/rpc/enums/WarningLightStatus.js b/lib/js/src/rpc/enums/WarningLightStatus.js new file mode 100644 index 00000000..8ca86d7d --- /dev/null +++ b/lib/js/src/rpc/enums/WarningLightStatus.js @@ -0,0 +1,103 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Reflects the status of a cluster instrument warning light. + * @typedef {Enum} WarningLightStatus + * @property {Object} _MAP + */ +class WarningLightStatus extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get WLS_OFF () { + return WarningLightStatus._MAP.WLS_OFF; + } + + /** + * @return {String} + */ + static get WLS_ON () { + return WarningLightStatus._MAP.WLS_ON; + } + + /** + * @return {String} + */ + static get WLS_FLASH () { + return WarningLightStatus._MAP.WLS_FLASH; + } + + /** + * @return {String} + */ + static get WLS_NOT_USED () { + return WarningLightStatus._MAP.WLS_NOT_USED; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return WarningLightStatus._valueForKey(key, WarningLightStatus._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return WarningLightStatus._keyForValue(value, WarningLightStatus._MAP); + } +} + +WarningLightStatus._MAP = Object.freeze({ + 'WLS_OFF': 'OFF', + 'WLS_ON': 'ON', + 'WLS_FLASH': 'FLASH', + 'WLS_NOT_USED': 'NOT_USED', +}); + +export { WarningLightStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/WayPointType.js b/lib/js/src/rpc/enums/WayPointType.js new file mode 100644 index 00000000..2027f8da --- /dev/null +++ b/lib/js/src/rpc/enums/WayPointType.js @@ -0,0 +1,87 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Describes what kind of waypoint is requested/provided. + * @typedef {Enum} WayPointType + * @property {Object} _MAP + */ +class WayPointType extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get ALL () { + return WayPointType._MAP.ALL; + } + + /** + * @return {String} + */ + static get DESTINATION () { + return WayPointType._MAP.DESTINATION; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return WayPointType._valueForKey(key, WayPointType._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return WayPointType._keyForValue(value, WayPointType._MAP); + } +} + +WayPointType._MAP = Object.freeze({ + 'ALL': 'ALL', + 'DESTINATION': 'DESTINATION', +}); + +export { WayPointType }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/WindowType.js b/lib/js/src/rpc/enums/WindowType.js new file mode 100644 index 00000000..9e3bb930 --- /dev/null +++ b/lib/js/src/rpc/enums/WindowType.js @@ -0,0 +1,89 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * @typedef {Enum} WindowType + * @property {Object} _MAP + */ +class WindowType extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * This window type describes the main window on a display. + * @return {String} + */ + static get MAIN () { + return WindowType._MAP.MAIN; + } + + /** + * A widget is a small window that the app can create to provide information and soft buttons for quick app + * control. + * @return {String} + */ + static get WIDGET () { + return WindowType._MAP.WIDGET; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return WindowType._valueForKey(key, WindowType._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return WindowType._keyForValue(value, WindowType._MAP); + } +} + +WindowType._MAP = Object.freeze({ + 'MAIN': 'MAIN', + 'WIDGET': 'WIDGET', +}); + +export { WindowType }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/WiperStatus.js b/lib/js/src/rpc/enums/WiperStatus.js new file mode 100644 index 00000000..6406ad50 --- /dev/null +++ b/lib/js/src/rpc/enums/WiperStatus.js @@ -0,0 +1,191 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Reflects the status of the wipers. + * @typedef {Enum} WiperStatus + * @property {Object} _MAP + */ +class WiperStatus extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {String} + */ + static get OFF () { + return WiperStatus._MAP.OFF; + } + + /** + * @return {String} + */ + static get AUTO_OFF () { + return WiperStatus._MAP.AUTO_OFF; + } + + /** + * @return {String} + */ + static get OFF_MOVING () { + return WiperStatus._MAP.OFF_MOVING; + } + + /** + * @return {String} + */ + static get MAN_INT_OFF () { + return WiperStatus._MAP.MAN_INT_OFF; + } + + /** + * @return {String} + */ + static get MAN_INT_ON () { + return WiperStatus._MAP.MAN_INT_ON; + } + + /** + * @return {String} + */ + static get MAN_LOW () { + return WiperStatus._MAP.MAN_LOW; + } + + /** + * @return {String} + */ + static get MAN_HIGH () { + return WiperStatus._MAP.MAN_HIGH; + } + + /** + * @return {String} + */ + static get MAN_FLICK () { + return WiperStatus._MAP.MAN_FLICK; + } + + /** + * @return {String} + */ + static get WASH () { + return WiperStatus._MAP.WASH; + } + + /** + * @return {String} + */ + static get AUTO_LOW () { + return WiperStatus._MAP.AUTO_LOW; + } + + /** + * @return {String} + */ + static get AUTO_HIGH () { + return WiperStatus._MAP.AUTO_HIGH; + } + + /** + * @return {String} + */ + static get COURTESYWIPE () { + return WiperStatus._MAP.COURTESYWIPE; + } + + /** + * @return {String} + */ + static get AUTO_ADJUST () { + return WiperStatus._MAP.AUTO_ADJUST; + } + + /** + * @return {String} + */ + static get STALLED () { + return WiperStatus._MAP.STALLED; + } + + /** + * @return {String} + */ + static get NO_DATA_EXISTS () { + return WiperStatus._MAP.NO_DATA_EXISTS; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return WiperStatus._valueForKey(key, WiperStatus._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return WiperStatus._keyForValue(value, WiperStatus._MAP); + } +} + +WiperStatus._MAP = Object.freeze({ + 'OFF': 'OFF', + 'AUTO_OFF': 'AUTO_OFF', + 'OFF_MOVING': 'OFF_MOVING', + 'MAN_INT_OFF': 'MAN_INT_OFF', + 'MAN_INT_ON': 'MAN_INT_ON', + 'MAN_LOW': 'MAN_LOW', + 'MAN_HIGH': 'MAN_HIGH', + 'MAN_FLICK': 'MAN_FLICK', + 'WASH': 'WASH', + 'AUTO_LOW': 'AUTO_LOW', + 'AUTO_HIGH': 'AUTO_HIGH', + 'COURTESYWIPE': 'COURTESYWIPE', + 'AUTO_ADJUST': 'AUTO_ADJUST', + 'STALLED': 'STALLED', + 'NO_DATA_EXISTS': 'NO_DATA_EXISTS', +}); + +export { WiperStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/enums/messageType.js b/lib/js/src/rpc/enums/messageType.js new file mode 100644 index 00000000..0b71228d --- /dev/null +++ b/lib/js/src/rpc/enums/messageType.js @@ -0,0 +1,95 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Enum } from '../../util/Enum.js'; + +/** + * Enumeration linking message types with function types in WiPro protocol. Assumes enumeration starts at value 0. + * @typedef {Enum} messageType + * @property {Object} _MAP + */ +class messageType extends Enum { + /** + * @constructor + */ + constructor () { + super(); + } + + /** + * @return {Number} + */ + static get request () { + return messageType._MAP.request; + } + + /** + * @return {Number} + */ + static get response () { + return messageType._MAP.response; + } + + /** + * @return {Number} + */ + static get notification () { + return messageType._MAP.notification; + } + + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + static valueForKey (key) { + return messageType._valueForKey(key, messageType._MAP); + } + + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + static keyForValue (value) { + return messageType._keyForValue(value, messageType._MAP); + } +} + +messageType._MAP = Object.freeze({ + 'request': 0, + 'response': 1, + 'notification': 2, +}); + +export { messageType }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/AddCommand.js b/lib/js/src/rpc/messages/AddCommand.js index 1af5205a..c0a4330f 100644 --- a/lib/js/src/rpc/messages/AddCommand.js +++ b/lib/js/src/rpc/messages/AddCommand.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -31,92 +32,94 @@ */ import { RpcRequest } from '../RpcRequest.js'; -import { Image } from '../structs/Image.js'; -import { MenuParams } from '../structs/MenuParams.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { MenuParams } from '../structs/MenuParams.js'; +import { Image } from '../structs/Image.js'; +/** + * Adds a command to the in application menu. Either menuParams or vrCommands must be provided. + */ class AddCommand extends RpcRequest { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.AddCommand); } - /** - * @param {Number} id - * @return {AddCommand} - */ + * @param {Number} id - unique ID of the command to add. + * @return {AddCommand} + */ setCmdID (id) { this.setParameter(AddCommand.KEY_CMD_ID, id); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getCmdID () { return this.getParameter(AddCommand.KEY_CMD_ID); } /** - * @param {MenuParams} menuParams - * @return {AddCommand} - */ - setMenuParams (menuParams) { - this.validateType(MenuParams, menuParams); - - this.setParameter(AddCommand.KEY_MENU_PARAMS, menuParams); + * @param {MenuParams} params - Optional sub value containing menu parameters + * @return {AddCommand} + */ + setMenuParams (params) { + this.validateType(MenuParams, params); + this.setParameter(AddCommand.KEY_MENU_PARAMS, params); return this; } /** - * @return {MenuParams} - */ + * @return {MenuParams} + */ getMenuParams () { return this.getObject(MenuParams, AddCommand.KEY_MENU_PARAMS); } /** - * @param {Array} vrCommands - * @return {AddCommand} - */ - setVrCommands (vrCommands) { - this.setParameter(AddCommand.KEY_VR_COMMANDS, vrCommands); + * @param {String[]} commands - An array of strings to be used as VR synonyms for this command. If this array is + * provided, it may not be empty. + * @return {AddCommand} + */ + setVrCommands (commands) { + this.setParameter(AddCommand.KEY_VR_COMMANDS, commands); return this; } /** - * @return {Array} - */ + * @return {String[]} + */ getVrCommands () { return this.getParameter(AddCommand.KEY_VR_COMMANDS); } /** - * @param {Image} icon - * @return {AddCommand} - */ + * @param {Image} icon - Image struct determining whether static or dynamic icon. If omitted on supported displays, + * no (or the default if applicable) icon shall be displayed. + * @return {AddCommand} + */ setCmdIcon (icon) { this.validateType(Image, icon); - this.setParameter(AddCommand.KEY_CMD_ICON, icon); return this; } /** - * @return {Image} - */ + * @return {Image} + */ getCmdIcon () { return this.getObject(Image, AddCommand.KEY_CMD_ICON); } } -AddCommand.KEY_CMD_ICON = 'cmdIcon'; -AddCommand.KEY_MENU_PARAMS = 'menuParams'; AddCommand.KEY_CMD_ID = 'cmdID'; +AddCommand.KEY_MENU_PARAMS = 'menuParams'; AddCommand.KEY_VR_COMMANDS = 'vrCommands'; +AddCommand.KEY_CMD_ICON = 'cmdIcon'; -export { AddCommand }; +export { AddCommand }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/AddCommandResponse.js b/lib/js/src/rpc/messages/AddCommandResponse.js index a4e655e9..a549e54b 100644 --- a/lib/js/src/rpc/messages/AddCommandResponse.js +++ b/lib/js/src/rpc/messages/AddCommandResponse.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,17 +31,18 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcResponse } from '../RpcResponse.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; class AddCommandResponse extends RpcResponse { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.AddCommand); } } -export { AddCommandResponse }; + +export { AddCommandResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/AddSubMenu.js b/lib/js/src/rpc/messages/AddSubMenu.js new file mode 100644 index 00000000..1b85203f --- /dev/null +++ b/lib/js/src/rpc/messages/AddSubMenu.js @@ -0,0 +1,144 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { MenuLayout } from '../enums/MenuLayout.js'; +import { Image } from '../structs/Image.js'; + +/** + * Adds a sub menu to the in-application menu. + */ +class AddSubMenu extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.AddSubMenu); + } + + /** + * @param {Number} id - unique ID of the sub menu to add. + * @return {AddSubMenu} + */ + setMenuID (id) { + this.setParameter(AddSubMenu.KEY_MENU_ID, id); + return this; + } + + /** + * @return {Number} + */ + getMenuID () { + return this.getParameter(AddSubMenu.KEY_MENU_ID); + } + + /** + * @param {Number} position - Position within the items that are are at top level of the in application menu. 0 will + * insert at the front. 1 will insert at the second position. If position is greater or + * equal than the number of items on top level, the sub menu will be appended to the end. + * Position of any submenu will always be located before the return and exit options If + * this param was omitted the entry will be added at the end. + * @return {AddSubMenu} + */ + setPosition (position) { + this.setParameter(AddSubMenu.KEY_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getPosition () { + return this.getParameter(AddSubMenu.KEY_POSITION); + } + + /** + * @param {String} name - Text to show in the menu for this sub menu. + * @return {AddSubMenu} + */ + setMenuName (name) { + this.setParameter(AddSubMenu.KEY_MENU_NAME, name); + return this; + } + + /** + * @return {String} + */ + getMenuName () { + return this.getParameter(AddSubMenu.KEY_MENU_NAME); + } + + /** + * @param {Image} icon - The image field for AddSubMenu + * @return {AddSubMenu} + */ + setMenuIcon (icon) { + this.validateType(Image, icon); + this.setParameter(AddSubMenu.KEY_MENU_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getMenuIcon () { + return this.getObject(Image, AddSubMenu.KEY_MENU_ICON); + } + + /** + * @param {MenuLayout} layout - Sets the layout of the submenu screen. + * @return {AddSubMenu} + */ + setMenuLayout (layout) { + this.validateType(MenuLayout, layout); + this.setParameter(AddSubMenu.KEY_MENU_LAYOUT, layout); + return this; + } + + /** + * @return {MenuLayout} + */ + getMenuLayout () { + return this.getObject(MenuLayout, AddSubMenu.KEY_MENU_LAYOUT); + } +} + +AddSubMenu.KEY_MENU_ID = 'menuID'; +AddSubMenu.KEY_POSITION = 'position'; +AddSubMenu.KEY_MENU_NAME = 'menuName'; +AddSubMenu.KEY_MENU_ICON = 'menuIcon'; +AddSubMenu.KEY_MENU_LAYOUT = 'menuLayout'; + +export { AddSubMenu }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/AddSubMenuResponse.js b/lib/js/src/rpc/messages/AddSubMenuResponse.js new file mode 100644 index 00000000..d47863db --- /dev/null +++ b/lib/js/src/rpc/messages/AddSubMenuResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class AddSubMenuResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.AddSubMenu); + } +} + + +export { AddSubMenuResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/Alert.js b/lib/js/src/rpc/messages/Alert.js new file mode 100644 index 00000000..2e510643 --- /dev/null +++ b/lib/js/src/rpc/messages/Alert.js @@ -0,0 +1,235 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { SoftButton } from '../structs/SoftButton.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { Image } from '../structs/Image.js'; + +/** + * Shows an alert which typically consists of text-to-speech message and text on the display. At least either + * alertText1, alertText2 or TTSChunks need to be provided. + */ +class Alert extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.Alert); + } + + /** + * @param {String} text1 - The first line of the alert text field + * @return {Alert} + */ + setAlertText1 (text1) { + this.setParameter(Alert.KEY_ALERT_TEXT_1, text1); + return this; + } + + /** + * @return {String} + */ + getAlertText1 () { + return this.getParameter(Alert.KEY_ALERT_TEXT_1); + } + + /** + * @param {String} text2 - The second line of the alert text field + * @return {Alert} + */ + setAlertText2 (text2) { + this.setParameter(Alert.KEY_ALERT_TEXT_2, text2); + return this; + } + + /** + * @return {String} + */ + getAlertText2 () { + return this.getParameter(Alert.KEY_ALERT_TEXT_2); + } + + /** + * @param {String} text3 - The optional third line of the alert text field + * @return {Alert} + */ + setAlertText3 (text3) { + this.setParameter(Alert.KEY_ALERT_TEXT_3, text3); + return this; + } + + /** + * @return {String} + */ + getAlertText3 () { + return this.getParameter(Alert.KEY_ALERT_TEXT_3); + } + + /** + * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. + * @return {Alert} + */ + setTtsChunks (chunks) { + this.validateType(TTSChunk, chunks, true); + this.setParameter(Alert.KEY_TTS_CHUNKS, chunks); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getTtsChunks () { + return this.getObject(TTSChunk, Alert.KEY_TTS_CHUNKS); + } + + /** + * @param {Number} duration - Timeout in milliseconds. Typical timeouts are 3-5 seconds. If omitted, timeout is set + * to 5s. + * @return {Alert} + */ + setDuration (duration) { + this.setParameter(Alert.KEY_DURATION, duration); + return this; + } + + /** + * @return {Number} + */ + getDuration () { + return this.getParameter(Alert.KEY_DURATION); + } + + /** + * @param {Boolean} tone - Defines if tone should be played. Tone is played before TTS. If omitted, no tone is + * played. + * @return {Alert} + */ + setPlayTone (tone) { + this.setParameter(Alert.KEY_PLAY_TONE, tone); + return this; + } + + /** + * @return {Boolean} + */ + getPlayTone () { + return this.getParameter(Alert.KEY_PLAY_TONE); + } + + /** + * @param {Boolean} indicator - If supported on the given platform, the alert GUI will include some sort of + * animation indicating that loading of a feature is progressing. e.g. a spinning wheel + * or hourglass, etc. + * @return {Alert} + */ + setProgressIndicator (indicator) { + this.setParameter(Alert.KEY_PROGRESS_INDICATOR, indicator); + return this; + } + + /** + * @return {Boolean} + */ + getProgressIndicator () { + return this.getParameter(Alert.KEY_PROGRESS_INDICATOR); + } + + /** + * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, the displayed alert + * shall not have any SoftButtons. + * @return {Alert} + */ + setSoftButtons (buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(Alert.KEY_SOFT_BUTTONS, buttons); + return this; + } + + /** + * @return {SoftButton[]} + */ + getSoftButtons () { + return this.getObject(SoftButton, Alert.KEY_SOFT_BUTTONS); + } + + /** + * @param {Image} icon - Image struct determining whether static or dynamic icon. If omitted on supported displays, + * no (or the default if applicable) icon should be displayed. + * @return {Alert} + */ + setAlertIcon (icon) { + this.validateType(Image, icon); + this.setParameter(Alert.KEY_ALERT_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getAlertIcon () { + return this.getObject(Image, Alert.KEY_ALERT_ICON); + } + + /** + * @param {Number} id - An ID for this specific alert to allow cancellation through the `CancelInteraction` RPC. + * @return {Alert} + */ + setCancelID (id) { + this.setParameter(Alert.KEY_CANCEL_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCancelID () { + return this.getParameter(Alert.KEY_CANCEL_ID); + } +} + +Alert.KEY_ALERT_TEXT_1 = 'alertText1'; +Alert.KEY_ALERT_TEXT_2 = 'alertText2'; +Alert.KEY_ALERT_TEXT_3 = 'alertText3'; +Alert.KEY_TTS_CHUNKS = 'ttsChunks'; +Alert.KEY_DURATION = 'duration'; +Alert.KEY_PLAY_TONE = 'playTone'; +Alert.KEY_PROGRESS_INDICATOR = 'progressIndicator'; +Alert.KEY_SOFT_BUTTONS = 'softButtons'; +Alert.KEY_ALERT_ICON = 'alertIcon'; +Alert.KEY_CANCEL_ID = 'cancelID'; + +export { Alert }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/AlertManeuver.js b/lib/js/src/rpc/messages/AlertManeuver.js new file mode 100644 index 00000000..7875fb80 --- /dev/null +++ b/lib/js/src/rpc/messages/AlertManeuver.js @@ -0,0 +1,87 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { SoftButton } from '../structs/SoftButton.js'; + +class AlertManeuver extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.AlertManeuver); + } + + /** + * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk + * @return {AlertManeuver} + */ + setTtsChunks (chunks) { + this.validateType(TTSChunk, chunks, true); + this.setParameter(AlertManeuver.KEY_TTS_CHUNKS, chunks); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getTtsChunks () { + return this.getObject(TTSChunk, AlertManeuver.KEY_TTS_CHUNKS); + } + + /** + * @param {SoftButton[]} buttons - If omitted on supported displays, only the system defined "Close" SoftButton + * shall be displayed. + * @return {AlertManeuver} + */ + setSoftButtons (buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(AlertManeuver.KEY_SOFT_BUTTONS, buttons); + return this; + } + + /** + * @return {SoftButton[]} + */ + getSoftButtons () { + return this.getObject(SoftButton, AlertManeuver.KEY_SOFT_BUTTONS); + } +} + +AlertManeuver.KEY_TTS_CHUNKS = 'ttsChunks'; +AlertManeuver.KEY_SOFT_BUTTONS = 'softButtons'; + +export { AlertManeuver }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/AlertManeuverResponse.js b/lib/js/src/rpc/messages/AlertManeuverResponse.js new file mode 100644 index 00000000..b9555952 --- /dev/null +++ b/lib/js/src/rpc/messages/AlertManeuverResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class AlertManeuverResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.AlertManeuver); + } +} + + +export { AlertManeuverResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/AlertResponse.js b/lib/js/src/rpc/messages/AlertResponse.js new file mode 100644 index 00000000..3a432b55 --- /dev/null +++ b/lib/js/src/rpc/messages/AlertResponse.js @@ -0,0 +1,67 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class AlertResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.Alert); + } + + /** + * @param {Number} time - Amount of time (in seconds) that an app must wait before resending an alert. If provided, + * another system event or overlay currently has a higher priority than this alert. An app + * must not send an alert without waiting at least the amount of time dictated. + * @return {AlertResponse} + */ + setTryAgainTime (time) { + this.setParameter(AlertResponse.KEY_TRY_AGAIN_TIME, time); + return this; + } + + /** + * @return {Number} + */ + getTryAgainTime () { + return this.getParameter(AlertResponse.KEY_TRY_AGAIN_TIME); + } +} + +AlertResponse.KEY_TRY_AGAIN_TIME = 'tryAgainTime'; + +export { AlertResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ButtonPress.js b/lib/js/src/rpc/messages/ButtonPress.js new file mode 100644 index 00000000..60157cdb --- /dev/null +++ b/lib/js/src/rpc/messages/ButtonPress.js @@ -0,0 +1,122 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { ButtonName } from '../enums/ButtonName.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { ButtonPressMode } from '../enums/ButtonPressMode.js'; +import { ModuleType } from '../enums/ModuleType.js'; +import { RpcRequest } from '../RpcRequest.js'; + +class ButtonPress extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ButtonPress); + } + + /** + * @param {ModuleType} type - The module where the button should be pressed + * @return {ButtonPress} + */ + setModuleType (type) { + this.validateType(ModuleType, type); + this.setParameter(ButtonPress.KEY_MODULE_TYPE, type); + return this; + } + + /** + * @return {ModuleType} + */ + getModuleType () { + return this.getObject(ModuleType, ButtonPress.KEY_MODULE_TYPE); + } + + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {ButtonPress} + */ + setModuleId (id) { + this.setParameter(ButtonPress.KEY_MODULE_ID, id); + return this; + } + + /** + * @return {String} + */ + getModuleId () { + return this.getParameter(ButtonPress.KEY_MODULE_ID); + } + + /** + * @param {ButtonName} name - The name of supported RC climate or radio button. + * @return {ButtonPress} + */ + setButtonName (name) { + this.validateType(ButtonName, name); + this.setParameter(ButtonPress.KEY_BUTTON_NAME, name); + return this; + } + + /** + * @return {ButtonName} + */ + getButtonName () { + return this.getObject(ButtonName, ButtonPress.KEY_BUTTON_NAME); + } + + /** + * @param {ButtonPressMode} mode - Indicates whether this is a LONG or SHORT button press event. + * @return {ButtonPress} + */ + setButtonPressMode (mode) { + this.validateType(ButtonPressMode, mode); + this.setParameter(ButtonPress.KEY_BUTTON_PRESS_MODE, mode); + return this; + } + + /** + * @return {ButtonPressMode} + */ + getButtonPressMode () { + return this.getObject(ButtonPressMode, ButtonPress.KEY_BUTTON_PRESS_MODE); + } +} + +ButtonPress.KEY_MODULE_TYPE = 'moduleType'; +ButtonPress.KEY_MODULE_ID = 'moduleId'; +ButtonPress.KEY_BUTTON_NAME = 'buttonName'; +ButtonPress.KEY_BUTTON_PRESS_MODE = 'buttonPressMode'; + +export { ButtonPress }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ButtonPressResponse.js b/lib/js/src/rpc/messages/ButtonPressResponse.js new file mode 100644 index 00000000..8bec65fe --- /dev/null +++ b/lib/js/src/rpc/messages/ButtonPressResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ButtonPressResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ButtonPress); + } +} + + +export { ButtonPressResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CancelInteraction.js b/lib/js/src/rpc/messages/CancelInteraction.js new file mode 100644 index 00000000..8eb9a7f3 --- /dev/null +++ b/lib/js/src/rpc/messages/CancelInteraction.js @@ -0,0 +1,88 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Close an active interaction on the HMI. + */ +class CancelInteraction extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CancelInteraction); + } + + /** + * @param {Number} id - The ID of the specific interaction you want to dismiss. If not set, the most recent of the + * RPC type set in functionID will be dismissed. + * @return {CancelInteraction} + */ + setCancelID (id) { + this.setParameter(CancelInteraction.KEY_CANCEL_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCancelID () { + return this.getParameter(CancelInteraction.KEY_CANCEL_ID); + } + + /** + * @param {Number} id - The ID of the type of interaction the developer wants to dismiss. Only values 10, + * (PerformInteractionID), 12 (AlertID), 25 (ScrollableMessageID), and 26 (SliderID) are + * permitted. + * @return {CancelInteraction} + */ + setFunctionID (id) { + this.setParameter(CancelInteraction.KEY_FUNCTION_ID, id); + return this; + } + + /** + * @return {Number} + */ + getFunctionID () { + return this.getParameter(CancelInteraction.KEY_FUNCTION_ID); + } +} + +CancelInteraction.KEY_CANCEL_ID = 'cancelID'; +CancelInteraction.KEY_FUNCTION_ID = 'functionID'; + +export { CancelInteraction }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CancelInteractionResponse.js b/lib/js/src/rpc/messages/CancelInteractionResponse.js new file mode 100644 index 00000000..d78bfb46 --- /dev/null +++ b/lib/js/src/rpc/messages/CancelInteractionResponse.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * If no applicable request can be dismissed, the result will be IGNORED. + */ +class CancelInteractionResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CancelInteraction); + } +} + + +export { CancelInteractionResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ChangeRegistration.js b/lib/js/src/rpc/messages/ChangeRegistration.js new file mode 100644 index 00000000..bb688ce9 --- /dev/null +++ b/lib/js/src/rpc/messages/ChangeRegistration.js @@ -0,0 +1,155 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { Language } from '../enums/Language.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +class ChangeRegistration extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ChangeRegistration); + } + + /** + * @param {Language} language - Requested voice engine (VR+TTS) language registration + * @return {ChangeRegistration} + */ + setLanguage (language) { + this.validateType(Language, language); + this.setParameter(ChangeRegistration.KEY_LANGUAGE, language); + return this; + } + + /** + * @return {Language} + */ + getLanguage () { + return this.getObject(Language, ChangeRegistration.KEY_LANGUAGE); + } + + /** + * @param {Language} language - Request display language registration + * @return {ChangeRegistration} + */ + setHmiDisplayLanguage (language) { + this.validateType(Language, language); + this.setParameter(ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE, language); + return this; + } + + /** + * @return {Language} + */ + getHmiDisplayLanguage () { + return this.getObject(Language, ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE); + } + + /** + * @param {String} name - Request new app name registration + * @return {ChangeRegistration} + */ + setAppName (name) { + this.setParameter(ChangeRegistration.KEY_APP_NAME, name); + return this; + } + + /** + * @return {String} + */ + getAppName () { + return this.getParameter(ChangeRegistration.KEY_APP_NAME); + } + + /** + * @param {TTSChunk[]} name - Request new ttsName registration + * @return {ChangeRegistration} + */ + setTtsName (name) { + this.validateType(TTSChunk, name, true); + this.setParameter(ChangeRegistration.KEY_TTS_NAME, name); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getTtsName () { + return this.getObject(TTSChunk, ChangeRegistration.KEY_TTS_NAME); + } + + /** + * @param {String} name - Request new app short name registration + * @return {ChangeRegistration} + */ + setNgnMediaScreenAppName (name) { + this.setParameter(ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME, name); + return this; + } + + /** + * @return {String} + */ + getNgnMediaScreenAppName () { + return this.getParameter(ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME); + } + + /** + * @param {String[]} synonyms - Request new VR synonyms registration + * @return {ChangeRegistration} + */ + setVrSynonyms (synonyms) { + this.setParameter(ChangeRegistration.KEY_VR_SYNONYMS, synonyms); + return this; + } + + /** + * @return {String[]} + */ + getVrSynonyms () { + return this.getParameter(ChangeRegistration.KEY_VR_SYNONYMS); + } +} + +ChangeRegistration.KEY_LANGUAGE = 'language'; +ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; +ChangeRegistration.KEY_APP_NAME = 'appName'; +ChangeRegistration.KEY_TTS_NAME = 'ttsName'; +ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME = 'ngnMediaScreenAppName'; +ChangeRegistration.KEY_VR_SYNONYMS = 'vrSynonyms'; + +export { ChangeRegistration }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ChangeRegistrationResponse.js b/lib/js/src/rpc/messages/ChangeRegistrationResponse.js new file mode 100644 index 00000000..3f119b3e --- /dev/null +++ b/lib/js/src/rpc/messages/ChangeRegistrationResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ChangeRegistrationResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ChangeRegistration); + } +} + + +export { ChangeRegistrationResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CloseApplication.js b/lib/js/src/rpc/messages/CloseApplication.js new file mode 100644 index 00000000..8f850979 --- /dev/null +++ b/lib/js/src/rpc/messages/CloseApplication.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Request from the application to exit the foreground and enter HMI_NONE. + */ +class CloseApplication extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CloseApplication); + } +} + + +export { CloseApplication }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CloseApplicationResponse.js b/lib/js/src/rpc/messages/CloseApplicationResponse.js new file mode 100644 index 00000000..7fbff7c0 --- /dev/null +++ b/lib/js/src/rpc/messages/CloseApplicationResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class CloseApplicationResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CloseApplication); + } +} + + +export { CloseApplicationResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CreateInteractionChoiceSet.js b/lib/js/src/rpc/messages/CreateInteractionChoiceSet.js new file mode 100644 index 00000000..e278b6c6 --- /dev/null +++ b/lib/js/src/rpc/messages/CreateInteractionChoiceSet.js @@ -0,0 +1,88 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { Choice } from '../structs/Choice.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * creates interaction choice set to be used later by performInteraction + */ +class CreateInteractionChoiceSet extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CreateInteractionChoiceSet); + } + + /** + * @param {Number} id - Unique ID used for this interaction choice set. + * @return {CreateInteractionChoiceSet} + */ + setInteractionChoiceSetID (id) { + this.setParameter(CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID, id); + return this; + } + + /** + * @return {Number} + */ + getInteractionChoiceSetID () { + return this.getParameter(CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID); + } + + /** + * @param {Choice[]} set - A choice is an option given to the user, which can be selected either by menu, or through + * voice recognition system. + * @return {CreateInteractionChoiceSet} + */ + setChoiceSet (set) { + this.validateType(Choice, set, true); + this.setParameter(CreateInteractionChoiceSet.KEY_CHOICE_SET, set); + return this; + } + + /** + * @return {Choice[]} + */ + getChoiceSet () { + return this.getObject(Choice, CreateInteractionChoiceSet.KEY_CHOICE_SET); + } +} + +CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID = 'interactionChoiceSetID'; +CreateInteractionChoiceSet.KEY_CHOICE_SET = 'choiceSet'; + +export { CreateInteractionChoiceSet }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CreateInteractionChoiceSetResponse.js b/lib/js/src/rpc/messages/CreateInteractionChoiceSetResponse.js new file mode 100644 index 00000000..beb01f6a --- /dev/null +++ b/lib/js/src/rpc/messages/CreateInteractionChoiceSetResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class CreateInteractionChoiceSetResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CreateInteractionChoiceSet); + } +} + + +export { CreateInteractionChoiceSetResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CreateWindow.js b/lib/js/src/rpc/messages/CreateWindow.js new file mode 100644 index 00000000..92c1c82d --- /dev/null +++ b/lib/js/src/rpc/messages/CreateWindow.js @@ -0,0 +1,155 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { WindowType } from '../enums/WindowType.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Create a new window on the display with the specified window type. + */ +class CreateWindow extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CreateWindow); + } + + /** + * @param {Number} id - A unique ID to identify the window. The value of '0' will always be the default main window + * on the main display and should not be used in this context as it will already be created for + * the app. See PredefinedWindows enum. Creating a window with an ID that is already in use + * will be rejected with `INVALID_ID`. + * @return {CreateWindow} + */ + setWindowID (id) { + this.setParameter(CreateWindow.KEY_WINDOW_ID, id); + return this; + } + + /** + * @return {Number} + */ + getWindowID () { + return this.getParameter(CreateWindow.KEY_WINDOW_ID); + } + + /** + * @param {String} name - The window name to be used by the HMI. The name of the pre-created default window will + * match the app name. Multiple apps can share the same window name except for the default + * main window. Creating a window with a name which is already in use by the app will result + * in `DUPLICATE_NAME`. + * @return {CreateWindow} + */ + setWindowName (name) { + this.setParameter(CreateWindow.KEY_WINDOW_NAME, name); + return this; + } + + /** + * @return {String} + */ + getWindowName () { + return this.getParameter(CreateWindow.KEY_WINDOW_NAME); + } + + /** + * @param {WindowType} type - The type of the window to be created. Main window or widget. + * @return {CreateWindow} + */ + setType (type) { + this.validateType(WindowType, type); + this.setParameter(CreateWindow.KEY_TYPE, type); + return this; + } + + /** + * @return {WindowType} + */ + getType () { + return this.getObject(WindowType, CreateWindow.KEY_TYPE); + } + + /** + * @param {String} type - Allows an app to create a widget related to a specific service type. As an example if a + * `MEDIA` app becomes active, this app becomes audible and is allowed to play audio. Actions + * such as skip or play/pause will be directed to this active media app. In case of widgets, + * the system can provide a single "media" widget which will act as a placeholder for the + * active media app. It is only allowed to have one window per service type. This means that + * a media app can only have a single MEDIA widget. Still the app can create widgets omitting + * this parameter. Those widgets would be available as app specific widgets that are + * permanently included in the HMI. This parameter is related to widgets only. The default + * main window, which is pre-created during app registration, will be created based on the + * HMI types specified in the app registration request. + * @return {CreateWindow} + */ + setAssociatedServiceType (type) { + this.setParameter(CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getAssociatedServiceType () { + return this.getParameter(CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE); + } + + /** + * @param {Number} id - Optional parameter. Specify whether the content sent to an existing window should be + * duplicated to the created window. If there isn't a window with the ID, the request will be + * rejected with `INVALID_DATA`. + * @return {CreateWindow} + */ + setDuplicateUpdatesFromWindowID (id) { + this.setParameter(CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID, id); + return this; + } + + /** + * @return {Number} + */ + getDuplicateUpdatesFromWindowID () { + return this.getParameter(CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID); + } +} + +CreateWindow.KEY_WINDOW_ID = 'windowID'; +CreateWindow.KEY_WINDOW_NAME = 'windowName'; +CreateWindow.KEY_TYPE = 'type'; +CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE = 'associatedServiceType'; +CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID = 'duplicateUpdatesFromWindowID'; + +export { CreateWindow }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/CreateWindowResponse.js b/lib/js/src/rpc/messages/CreateWindowResponse.js new file mode 100644 index 00000000..b7fbb63a --- /dev/null +++ b/lib/js/src/rpc/messages/CreateWindowResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class CreateWindowResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.CreateWindow); + } +} + + +export { CreateWindowResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteCommand.js b/lib/js/src/rpc/messages/DeleteCommand.js new file mode 100644 index 00000000..7c894bc6 --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteCommand.js @@ -0,0 +1,68 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Deletes all commands from the in-application menu with the specified command id. + */ +class DeleteCommand extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteCommand); + } + + /** + * @param {Number} id - ID of the command(s) to delete. + * @return {DeleteCommand} + */ + setCmdID (id) { + this.setParameter(DeleteCommand.KEY_CMD_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCmdID () { + return this.getParameter(DeleteCommand.KEY_CMD_ID); + } +} + +DeleteCommand.KEY_CMD_ID = 'cmdID'; + +export { DeleteCommand }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteCommandResponse.js b/lib/js/src/rpc/messages/DeleteCommandResponse.js new file mode 100644 index 00000000..56acc065 --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteCommandResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class DeleteCommandResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteCommand); + } +} + + +export { DeleteCommandResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteFile.js b/lib/js/src/rpc/messages/DeleteFile.js new file mode 100644 index 00000000..3d489d17 --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteFile.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Used to delete a file resident on the module in the app's local cache. Not supported on first generation SDL enabled + * vehicles. + */ +class DeleteFile extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteFile); + } + + /** + * @param {String} name - File reference name. + * @return {DeleteFile} + */ + setSdlFileName (name) { + this.setParameter(DeleteFile.KEY_SDL_FILE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getSdlFileName () { + return this.getParameter(DeleteFile.KEY_SDL_FILE_NAME); + } +} + +DeleteFile.KEY_SDL_FILE_NAME = 'syncFileName'; + +export { DeleteFile }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteFileResponse.js b/lib/js/src/rpc/messages/DeleteFileResponse.js new file mode 100644 index 00000000..34457726 --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteFileResponse.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * Response is sent, when the file data was deleted (success case). Or when an error occurred. Not supported on First + * generation SDL enabled vehicles. + */ +class DeleteFileResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteFile); + } + + /** + * @param {Number} available - Provides the total local space available on the module for the registered app. + * @return {DeleteFileResponse} + */ + setSpaceAvailable (available) { + this.setParameter(DeleteFileResponse.KEY_SPACE_AVAILABLE, available); + return this; + } + + /** + * @return {Number} + */ + getSpaceAvailable () { + return this.getParameter(DeleteFileResponse.KEY_SPACE_AVAILABLE); + } +} + +DeleteFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable'; + +export { DeleteFileResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteInteractionChoiceSet.js b/lib/js/src/rpc/messages/DeleteInteractionChoiceSet.js new file mode 100644 index 00000000..85f0a47f --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteInteractionChoiceSet.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Deletes interaction choice set that has been created with "CreateInteractionChoiceSet". The interaction may only be + * deleted when not currently in use by a "performInteraction". + */ +class DeleteInteractionChoiceSet extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteInteractionChoiceSet); + } + + /** + * @param {Number} id - ID of the interaction choice set to delete. + * @return {DeleteInteractionChoiceSet} + */ + setInteractionChoiceSetID (id) { + this.setParameter(DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID, id); + return this; + } + + /** + * @return {Number} + */ + getInteractionChoiceSetID () { + return this.getParameter(DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID); + } +} + +DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID = 'interactionChoiceSetID'; + +export { DeleteInteractionChoiceSet }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteInteractionChoiceSetResponse.js b/lib/js/src/rpc/messages/DeleteInteractionChoiceSetResponse.js new file mode 100644 index 00000000..2f46dce0 --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteInteractionChoiceSetResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class DeleteInteractionChoiceSetResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteInteractionChoiceSet); + } +} + + +export { DeleteInteractionChoiceSetResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteSubMenu.js b/lib/js/src/rpc/messages/DeleteSubMenu.js new file mode 100644 index 00000000..26132c1f --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteSubMenu.js @@ -0,0 +1,68 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Deletes a submenu from the in-application menu. + */ +class DeleteSubMenu extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteSubMenu); + } + + /** + * @param {Number} id - The "menuID" of the submenu to delete. (See addSubMenu.menuID) + * @return {DeleteSubMenu} + */ + setMenuID (id) { + this.setParameter(DeleteSubMenu.KEY_MENU_ID, id); + return this; + } + + /** + * @return {Number} + */ + getMenuID () { + return this.getParameter(DeleteSubMenu.KEY_MENU_ID); + } +} + +DeleteSubMenu.KEY_MENU_ID = 'menuID'; + +export { DeleteSubMenu }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteSubMenuResponse.js b/lib/js/src/rpc/messages/DeleteSubMenuResponse.js new file mode 100644 index 00000000..44624c53 --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteSubMenuResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class DeleteSubMenuResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteSubMenu); + } +} + + +export { DeleteSubMenuResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteWindow.js b/lib/js/src/rpc/messages/DeleteWindow.js new file mode 100644 index 00000000..c4c99d1f --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteWindow.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Deletes previously created window of the SDL application. + */ +class DeleteWindow extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteWindow); + } + + /** + * @param {Number} id - A unique ID to identify the window. The value of '0' will always be the default main window + * on the main display and cannot be deleted. See PredefinedWindows enum. + * @return {DeleteWindow} + */ + setWindowID (id) { + this.setParameter(DeleteWindow.KEY_WINDOW_ID, id); + return this; + } + + /** + * @return {Number} + */ + getWindowID () { + return this.getParameter(DeleteWindow.KEY_WINDOW_ID); + } +} + +DeleteWindow.KEY_WINDOW_ID = 'windowID'; + +export { DeleteWindow }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DeleteWindowResponse.js b/lib/js/src/rpc/messages/DeleteWindowResponse.js new file mode 100644 index 00000000..f4f9c409 --- /dev/null +++ b/lib/js/src/rpc/messages/DeleteWindowResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class DeleteWindowResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DeleteWindow); + } +} + + +export { DeleteWindowResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DiagnosticMessage.js b/lib/js/src/rpc/messages/DiagnosticMessage.js new file mode 100644 index 00000000..ddddeb28 --- /dev/null +++ b/lib/js/src/rpc/messages/DiagnosticMessage.js @@ -0,0 +1,102 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Non periodic vehicle diagnostic request + */ +class DiagnosticMessage extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DiagnosticMessage); + } + + /** + * @param {Number} id - Name of target ECU. + * @return {DiagnosticMessage} + */ + setTargetID (id) { + this.setParameter(DiagnosticMessage.KEY_TARGET_ID, id); + return this; + } + + /** + * @return {Number} + */ + getTargetID () { + return this.getParameter(DiagnosticMessage.KEY_TARGET_ID); + } + + /** + * @param {Number} length - Length of message (in bytes). + * @return {DiagnosticMessage} + */ + setMessageLength (length) { + this.setParameter(DiagnosticMessage.KEY_MESSAGE_LENGTH, length); + return this; + } + + /** + * @return {Number} + */ + getMessageLength () { + return this.getParameter(DiagnosticMessage.KEY_MESSAGE_LENGTH); + } + + /** + * @param {Number[]} data - Array of bytes comprising CAN message. + * @return {DiagnosticMessage} + */ + setMessageData (data) { + this.setParameter(DiagnosticMessage.KEY_MESSAGE_DATA, data); + return this; + } + + /** + * @return {Number[]} + */ + getMessageData () { + return this.getParameter(DiagnosticMessage.KEY_MESSAGE_DATA); + } +} + +DiagnosticMessage.KEY_TARGET_ID = 'targetID'; +DiagnosticMessage.KEY_MESSAGE_LENGTH = 'messageLength'; +DiagnosticMessage.KEY_MESSAGE_DATA = 'messageData'; + +export { DiagnosticMessage }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DiagnosticMessageResponse.js b/lib/js/src/rpc/messages/DiagnosticMessageResponse.js new file mode 100644 index 00000000..32d28058 --- /dev/null +++ b/lib/js/src/rpc/messages/DiagnosticMessageResponse.js @@ -0,0 +1,65 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class DiagnosticMessageResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DiagnosticMessage); + } + + /** + * @param {Number[]} result - Array of bytes comprising CAN message result. + * @return {DiagnosticMessageResponse} + */ + setMessageDataResult (result) { + this.setParameter(DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT, result); + return this; + } + + /** + * @return {Number[]} + */ + getMessageDataResult () { + return this.getParameter(DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT); + } +} + +DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT = 'messageDataResult'; + +export { DiagnosticMessageResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DialNumber.js b/lib/js/src/rpc/messages/DialNumber.js new file mode 100644 index 00000000..d4ad65fb --- /dev/null +++ b/lib/js/src/rpc/messages/DialNumber.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Dials a phone number and switches to phone application. + */ +class DialNumber extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DialNumber); + } + + /** + * @param {String} number - Phone number is a string, which can be up to 40 chars. All characters shall be stripped + * from string except digits 0-9 and * # , ; + + * @return {DialNumber} + */ + setNumber (number) { + this.setParameter(DialNumber.KEY_NUMBER, number); + return this; + } + + /** + * @return {String} + */ + getNumber () { + return this.getParameter(DialNumber.KEY_NUMBER); + } +} + +DialNumber.KEY_NUMBER = 'number'; + +export { DialNumber }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/DialNumberResponse.js b/lib/js/src/rpc/messages/DialNumberResponse.js new file mode 100644 index 00000000..9b4eee9d --- /dev/null +++ b/lib/js/src/rpc/messages/DialNumberResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class DialNumberResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.DialNumber); + } +} + + +export { DialNumberResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/EncodedSyncPData.js b/lib/js/src/rpc/messages/EncodedSyncPData.js new file mode 100644 index 00000000..1a920ddd --- /dev/null +++ b/lib/js/src/rpc/messages/EncodedSyncPData.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Allows encoded data in the form of SyncP packets to be sent to the SYNC module. Legacy / v1 Protocol implementation; + * use SyncPData instead. *** DEPRECATED *** + */ +class EncodedSyncPData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.EncodedSyncPData); + } + + /** + * @param {String[]} data - Contains base64 encoded string of SyncP packets. + * @return {EncodedSyncPData} + */ + setData (data) { + this.setParameter(EncodedSyncPData.KEY_DATA, data); + return this; + } + + /** + * @return {String[]} + */ + getData () { + return this.getParameter(EncodedSyncPData.KEY_DATA); + } +} + +EncodedSyncPData.KEY_DATA = 'data'; + +export { EncodedSyncPData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/EncodedSyncPDataResponse.js b/lib/js/src/rpc/messages/EncodedSyncPDataResponse.js new file mode 100644 index 00000000..083f983a --- /dev/null +++ b/lib/js/src/rpc/messages/EncodedSyncPDataResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class EncodedSyncPDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.EncodedSyncPData); + } +} + + +export { EncodedSyncPDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/EndAudioPassThru.js b/lib/js/src/rpc/messages/EndAudioPassThru.js new file mode 100644 index 00000000..356b6644 --- /dev/null +++ b/lib/js/src/rpc/messages/EndAudioPassThru.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * When this request is invoked, the audio capture stops. + */ +class EndAudioPassThru extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.EndAudioPassThru); + } +} + + +export { EndAudioPassThru }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/EndAudioPassThruResponse.js b/lib/js/src/rpc/messages/EndAudioPassThruResponse.js new file mode 100644 index 00000000..1e072a1c --- /dev/null +++ b/lib/js/src/rpc/messages/EndAudioPassThruResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class EndAudioPassThruResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.EndAudioPassThru); + } +} + + +export { EndAudioPassThruResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GenericResponseResponse.js b/lib/js/src/rpc/messages/GenericResponseResponse.js new file mode 100644 index 00000000..51773a63 --- /dev/null +++ b/lib/js/src/rpc/messages/GenericResponseResponse.js @@ -0,0 +1,52 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * Generic Response is sent, when the name of a received msg cannot be retrieved. Only used in case of an error. + * Currently, only resultCode INVALID_DATA is used. + */ +class GenericResponseResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GenericResponse); + } +} + + +export { GenericResponseResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetAppServiceData.js b/lib/js/src/rpc/messages/GetAppServiceData.js new file mode 100644 index 00000000..e61a3a73 --- /dev/null +++ b/lib/js/src/rpc/messages/GetAppServiceData.js @@ -0,0 +1,90 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * This request asks the module for current data related to the specific service. It also includes an option to + * subscribe to that service for future updates + */ +class GetAppServiceData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetAppServiceData); + } + + /** + * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum + * equivalent types. Parameter is a string to allow for new service types to be used by apps + * on older versions of SDL Core. + * @return {GetAppServiceData} + */ + setServiceType (type) { + this.setParameter(GetAppServiceData.KEY_SERVICE_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getServiceType () { + return this.getParameter(GetAppServiceData.KEY_SERVICE_TYPE); + } + + /** + * @param {Boolean} subscribe - If true, the consumer is requesting to subscribe to all future updates from the + * service publisher. If false, the consumer doesn't wish to subscribe and should be + * unsubscribed if it was previously subscribed. + * @return {GetAppServiceData} + */ + setSubscribe (subscribe) { + this.setParameter(GetAppServiceData.KEY_SUBSCRIBE, subscribe); + return this; + } + + /** + * @return {Boolean} + */ + getSubscribe () { + return this.getParameter(GetAppServiceData.KEY_SUBSCRIBE); + } +} + +GetAppServiceData.KEY_SERVICE_TYPE = 'serviceType'; +GetAppServiceData.KEY_SUBSCRIBE = 'subscribe'; + +export { GetAppServiceData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetAppServiceDataResponse.js b/lib/js/src/rpc/messages/GetAppServiceDataResponse.js new file mode 100644 index 00000000..385f3a0f --- /dev/null +++ b/lib/js/src/rpc/messages/GetAppServiceDataResponse.js @@ -0,0 +1,72 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { AppServiceData } from '../structs/AppServiceData.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * This response includes the data that was requested from the specific service + */ +class GetAppServiceDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetAppServiceData); + } + + /** + * @param {AppServiceData} data - Contains all the current data of the app service. The serviceType will link to + * which of the service data objects are included in this object (e.g. if the service + * type is MEDIA, the mediaServiceData param should be included). + * @return {GetAppServiceDataResponse} + */ + setServiceData (data) { + this.validateType(AppServiceData, data); + this.setParameter(GetAppServiceDataResponse.KEY_SERVICE_DATA, data); + return this; + } + + /** + * @return {AppServiceData} + */ + getServiceData () { + return this.getObject(AppServiceData, GetAppServiceDataResponse.KEY_SERVICE_DATA); + } +} + +GetAppServiceDataResponse.KEY_SERVICE_DATA = 'serviceData'; + +export { GetAppServiceDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetCloudAppProperties.js b/lib/js/src/rpc/messages/GetCloudAppProperties.js new file mode 100644 index 00000000..02f7f94c --- /dev/null +++ b/lib/js/src/rpc/messages/GetCloudAppProperties.js @@ -0,0 +1,68 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * RPC used to get the current properties of a cloud application + */ +class GetCloudAppProperties extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetCloudAppProperties); + } + + /** + * @param {String} id + * @return {GetCloudAppProperties} + */ + setAppID (id) { + this.setParameter(GetCloudAppProperties.KEY_APP_ID, id); + return this; + } + + /** + * @return {String} + */ + getAppID () { + return this.getParameter(GetCloudAppProperties.KEY_APP_ID); + } +} + +GetCloudAppProperties.KEY_APP_ID = 'appID'; + +export { GetCloudAppProperties }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetCloudAppPropertiesResponse.js b/lib/js/src/rpc/messages/GetCloudAppPropertiesResponse.js new file mode 100644 index 00000000..65c371a0 --- /dev/null +++ b/lib/js/src/rpc/messages/GetCloudAppPropertiesResponse.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { CloudAppProperties } from '../structs/CloudAppProperties.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * The response to GetCloudAppProperties + */ +class GetCloudAppPropertiesResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetCloudAppProperties); + } + + /** + * @param {CloudAppProperties} properties - The requested cloud application properties + * @return {GetCloudAppPropertiesResponse} + */ + setProperties (properties) { + this.validateType(CloudAppProperties, properties); + this.setParameter(GetCloudAppPropertiesResponse.KEY_PROPERTIES, properties); + return this; + } + + /** + * @return {CloudAppProperties} + */ + getProperties () { + return this.getObject(CloudAppProperties, GetCloudAppPropertiesResponse.KEY_PROPERTIES); + } +} + +GetCloudAppPropertiesResponse.KEY_PROPERTIES = 'properties'; + +export { GetCloudAppPropertiesResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetDTCs.js b/lib/js/src/rpc/messages/GetDTCs.js new file mode 100644 index 00000000..427cb46c --- /dev/null +++ b/lib/js/src/rpc/messages/GetDTCs.js @@ -0,0 +1,85 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Vehicle module diagnostic trouble code request. + */ +class GetDTCs extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetDTCs); + } + + /** + * @param {Number} name - Name of ECU. + * @return {GetDTCs} + */ + setEcuName (name) { + this.setParameter(GetDTCs.KEY_ECU_NAME, name); + return this; + } + + /** + * @return {Number} + */ + getEcuName () { + return this.getParameter(GetDTCs.KEY_ECU_NAME); + } + + /** + * @param {Number} mask - DTC Mask Byte to be sent in diagnostic request to module . + * @return {GetDTCs} + */ + setDtcMask (mask) { + this.setParameter(GetDTCs.KEY_DTC_MASK, mask); + return this; + } + + /** + * @return {Number} + */ + getDtcMask () { + return this.getParameter(GetDTCs.KEY_DTC_MASK); + } +} + +GetDTCs.KEY_ECU_NAME = 'ecuName'; +GetDTCs.KEY_DTC_MASK = 'dtcMask'; + +export { GetDTCs }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetDTCsResponse.js b/lib/js/src/rpc/messages/GetDTCsResponse.js new file mode 100644 index 00000000..855c4588 --- /dev/null +++ b/lib/js/src/rpc/messages/GetDTCsResponse.js @@ -0,0 +1,84 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class GetDTCsResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetDTCs); + } + + /** + * @param {Number} header - 2 byte ECU Header for DTC response (as defined in VHR_Layout_Specification_DTCs.pdf) + * @return {GetDTCsResponse} + */ + setEcuHeader (header) { + this.setParameter(GetDTCsResponse.KEY_ECU_HEADER, header); + return this; + } + + /** + * @return {Number} + */ + getEcuHeader () { + return this.getParameter(GetDTCsResponse.KEY_ECU_HEADER); + } + + /** + * @param {String[]} dtc - Array of all reported DTCs on module (ecuHeader contains information if list is + * truncated). Each DTC is represented by 4 bytes (3 bytes of data and 1 byte status as + * defined in VHR_Layout_Specification_DTCs.pdf). + * @return {GetDTCsResponse} + */ + setDtc (dtc) { + this.setParameter(GetDTCsResponse.KEY_DTC, dtc); + return this; + } + + /** + * @return {String[]} + */ + getDtc () { + return this.getParameter(GetDTCsResponse.KEY_DTC); + } +} + +GetDTCsResponse.KEY_ECU_HEADER = 'ecuHeader'; +GetDTCsResponse.KEY_DTC = 'dtc'; + +export { GetDTCsResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetFile.js b/lib/js/src/rpc/messages/GetFile.js new file mode 100644 index 00000000..44c292af --- /dev/null +++ b/lib/js/src/rpc/messages/GetFile.js @@ -0,0 +1,139 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FileType } from '../enums/FileType.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * This request is sent to the module to retrieve a file + */ +class GetFile extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetFile); + } + + /** + * @param {String} name - File name that should be retrieved + * @return {GetFile} + */ + setFileName (name) { + this.setParameter(GetFile.KEY_FILE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getFileName () { + return this.getParameter(GetFile.KEY_FILE_NAME); + } + + /** + * @param {String} id - ID of the service that should have uploaded the requested file. + * @return {GetFile} + */ + setAppServiceId (id) { + this.setParameter(GetFile.KEY_APP_SERVICE_ID, id); + return this; + } + + /** + * @return {String} + */ + getAppServiceId () { + return this.getParameter(GetFile.KEY_APP_SERVICE_ID); + } + + /** + * @param {FileType} type - Selected file type. + * @return {GetFile} + */ + setFileType (type) { + this.validateType(FileType, type); + this.setParameter(GetFile.KEY_FILE_TYPE, type); + return this; + } + + /** + * @return {FileType} + */ + getFileType () { + return this.getObject(FileType, GetFile.KEY_FILE_TYPE); + } + + /** + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {GetFile} + */ + setOffset (offset) { + this.setParameter(GetFile.KEY_OFFSET, offset); + return this; + } + + /** + * @return {Number} + */ + getOffset () { + return this.getParameter(GetFile.KEY_OFFSET); + } + + /** + * @param {Number} length - Optional length in bytes for resuming partial data chunks If offset is set to 0, then + * length is the total length of the file to be retrieved + * @return {GetFile} + */ + setLength (length) { + this.setParameter(GetFile.KEY_LENGTH, length); + return this; + } + + /** + * @return {Number} + */ + getLength () { + return this.getParameter(GetFile.KEY_LENGTH); + } +} + +GetFile.KEY_FILE_NAME = 'fileName'; +GetFile.KEY_APP_SERVICE_ID = 'appServiceId'; +GetFile.KEY_FILE_TYPE = 'fileType'; +GetFile.KEY_OFFSET = 'offset'; +GetFile.KEY_LENGTH = 'length'; + +export { GetFile }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetFileResponse.js b/lib/js/src/rpc/messages/GetFileResponse.js new file mode 100644 index 00000000..5990c58e --- /dev/null +++ b/lib/js/src/rpc/messages/GetFileResponse.js @@ -0,0 +1,122 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; +import { FileType } from '../enums/FileType.js'; + +/** + * This response includes the data that is requested from the specific service + */ +class GetFileResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetFile); + } + + /** + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {GetFileResponse} + */ + setOffset (offset) { + this.setParameter(GetFileResponse.KEY_OFFSET, offset); + return this; + } + + /** + * @return {Number} + */ + getOffset () { + return this.getParameter(GetFileResponse.KEY_OFFSET); + } + + /** + * @param {Number} length - Optional length in bytes for resuming partial data chunks if offset is set to 0, then + * length is the total length of the file to be downloaded + * @return {GetFileResponse} + */ + setLength (length) { + this.setParameter(GetFileResponse.KEY_LENGTH, length); + return this; + } + + /** + * @return {Number} + */ + getLength () { + return this.getParameter(GetFileResponse.KEY_LENGTH); + } + + /** + * @param {FileType} type - File type that is being sent in response. + * @return {GetFileResponse} + */ + setFileType (type) { + this.validateType(FileType, type); + this.setParameter(GetFileResponse.KEY_FILE_TYPE, type); + return this; + } + + /** + * @return {FileType} + */ + getFileType () { + return this.getObject(FileType, GetFileResponse.KEY_FILE_TYPE); + } + + /** + * @param {Number} crc - Additional CRC32 checksum to protect data integrity up to 512 Mbits + * @return {GetFileResponse} + */ + setCrc (crc) { + this.setParameter(GetFileResponse.KEY_CRC, crc); + return this; + } + + /** + * @return {Number} + */ + getCrc () { + return this.getParameter(GetFileResponse.KEY_CRC); + } +} + +GetFileResponse.KEY_OFFSET = 'offset'; +GetFileResponse.KEY_LENGTH = 'length'; +GetFileResponse.KEY_FILE_TYPE = 'fileType'; +GetFileResponse.KEY_CRC = 'crc'; + +export { GetFileResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetInteriorVehicleData.js b/lib/js/src/rpc/messages/GetInteriorVehicleData.js new file mode 100644 index 00000000..6fcaaf85 --- /dev/null +++ b/lib/js/src/rpc/messages/GetInteriorVehicleData.js @@ -0,0 +1,107 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { ModuleType } from '../enums/ModuleType.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +class GetInteriorVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleData); + } + + /** + * @param {ModuleType} type - The type of a RC module to retrieve module data from the vehicle. In the future, this + * should be the Identification of a module. + * @return {GetInteriorVehicleData} + */ + setModuleType (type) { + this.validateType(ModuleType, type); + this.setParameter(GetInteriorVehicleData.KEY_MODULE_TYPE, type); + return this; + } + + /** + * @return {ModuleType} + */ + getModuleType () { + return this.getObject(ModuleType, GetInteriorVehicleData.KEY_MODULE_TYPE); + } + + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {GetInteriorVehicleData} + */ + setModuleId (id) { + this.setParameter(GetInteriorVehicleData.KEY_MODULE_ID, id); + return this; + } + + /** + * @return {String} + */ + getModuleId () { + return this.getParameter(GetInteriorVehicleData.KEY_MODULE_ID); + } + + /** + * @param {Boolean} subscribe - If subscribe is true, the head unit will register OnInteriorVehicleData + * notifications for the requested module (moduleId and moduleType). If subscribe is + * false, the head unit will unregister OnInteriorVehicleData notifications for the + * requested module (moduleId and moduleType). If subscribe is not included, the + * subscription status of the app for the requested module (moduleId and moduleType) + * will remain unchanged. + * @return {GetInteriorVehicleData} + */ + setSubscribe (subscribe) { + this.setParameter(GetInteriorVehicleData.KEY_SUBSCRIBE, subscribe); + return this; + } + + /** + * @return {Boolean} + */ + getSubscribe () { + return this.getParameter(GetInteriorVehicleData.KEY_SUBSCRIBE); + } +} + +GetInteriorVehicleData.KEY_MODULE_TYPE = 'moduleType'; +GetInteriorVehicleData.KEY_MODULE_ID = 'moduleId'; +GetInteriorVehicleData.KEY_SUBSCRIBE = 'subscribe'; + +export { GetInteriorVehicleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetInteriorVehicleDataConsent.js b/lib/js/src/rpc/messages/GetInteriorVehicleDataConsent.js new file mode 100644 index 00000000..ba0bc6f3 --- /dev/null +++ b/lib/js/src/rpc/messages/GetInteriorVehicleDataConsent.js @@ -0,0 +1,84 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { ModuleType } from '../enums/ModuleType.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +class GetInteriorVehicleDataConsent extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleDataConsent); + } + + /** + * @param {ModuleType} type - The module type that the app requests to control. + * @return {GetInteriorVehicleDataConsent} + */ + setModuleType (type) { + this.validateType(ModuleType, type); + this.setParameter(GetInteriorVehicleDataConsent.KEY_MODULE_TYPE, type); + return this; + } + + /** + * @return {ModuleType} + */ + getModuleType () { + return this.getObject(ModuleType, GetInteriorVehicleDataConsent.KEY_MODULE_TYPE); + } + + /** + * @param {String[]} ids - Ids of a module of same type, published by System Capability. + * @return {GetInteriorVehicleDataConsent} + */ + setModuleIds (ids) { + this.setParameter(GetInteriorVehicleDataConsent.KEY_MODULE_IDS, ids); + return this; + } + + /** + * @return {String[]} + */ + getModuleIds () { + return this.getParameter(GetInteriorVehicleDataConsent.KEY_MODULE_IDS); + } +} + +GetInteriorVehicleDataConsent.KEY_MODULE_TYPE = 'moduleType'; +GetInteriorVehicleDataConsent.KEY_MODULE_IDS = 'moduleIds'; + +export { GetInteriorVehicleDataConsent }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetInteriorVehicleDataConsentResponse.js b/lib/js/src/rpc/messages/GetInteriorVehicleDataConsentResponse.js new file mode 100644 index 00000000..2e2f58bf --- /dev/null +++ b/lib/js/src/rpc/messages/GetInteriorVehicleDataConsentResponse.js @@ -0,0 +1,67 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class GetInteriorVehicleDataConsentResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleDataConsent); + } + + /** + * @param {Boolean[]} allowed - This array has the same size as "moduleIds" in the request and each element + * corresponds to one moduleId If true, SDL grants the permission for the requested + * module If false, SDL denies the permission for the requested module. + * @return {GetInteriorVehicleDataConsentResponse} + */ + setAllowed (allowed) { + this.setParameter(GetInteriorVehicleDataConsentResponse.KEY_ALLOWED, allowed); + return this; + } + + /** + * @return {Boolean[]} + */ + getAllowed () { + return this.getParameter(GetInteriorVehicleDataConsentResponse.KEY_ALLOWED); + } +} + +GetInteriorVehicleDataConsentResponse.KEY_ALLOWED = 'allowed'; + +export { GetInteriorVehicleDataConsentResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetInteriorVehicleDataResponse.js b/lib/js/src/rpc/messages/GetInteriorVehicleDataResponse.js new file mode 100644 index 00000000..0390ea09 --- /dev/null +++ b/lib/js/src/rpc/messages/GetInteriorVehicleDataResponse.js @@ -0,0 +1,90 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { ModuleData } from '../structs/ModuleData.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class GetInteriorVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleData); + } + + /** + * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which + * data object exists in this struct. For example, if the moduleType is CLIMATE then a + * "climateControlData" should exist + * @return {GetInteriorVehicleDataResponse} + */ + setModuleData (data) { + this.validateType(ModuleData, data); + this.setParameter(GetInteriorVehicleDataResponse.KEY_MODULE_DATA, data); + return this; + } + + /** + * @return {ModuleData} + */ + getModuleData () { + return this.getObject(ModuleData, GetInteriorVehicleDataResponse.KEY_MODULE_DATA); + } + + /** + * @param {Boolean} subscribed - It is a conditional-mandatory parameter: must be returned in case "subscribe" + * parameter was present in the related request. if "true" - the "moduleType" from + * request is successfully subscribed and the head unit will send + * onInteriorVehicleData notifications for the moduleType. if "false" - the + * "moduleType" from request is either unsubscribed or failed to subscribe. + * @return {GetInteriorVehicleDataResponse} + */ + setIsSubscribed (subscribed) { + this.setParameter(GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED, subscribed); + return this; + } + + /** + * @return {Boolean} + */ + getIsSubscribed () { + return this.getParameter(GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED); + } +} + +GetInteriorVehicleDataResponse.KEY_MODULE_DATA = 'moduleData'; +GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED = 'isSubscribed'; + +export { GetInteriorVehicleDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetSystemCapability.js b/lib/js/src/rpc/messages/GetSystemCapability.js new file mode 100644 index 00000000..fa2197d5 --- /dev/null +++ b/lib/js/src/rpc/messages/GetSystemCapability.js @@ -0,0 +1,89 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { SystemCapabilityType } from '../enums/SystemCapabilityType.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Request for expanded information about a supported system/HMI capability + */ +class GetSystemCapability extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetSystemCapability); + } + + /** + * @param {SystemCapabilityType} type - The type of system capability to get more information on + * @return {GetSystemCapability} + */ + setSystemCapabilityType (type) { + this.validateType(SystemCapabilityType, type); + this.setParameter(GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE, type); + return this; + } + + /** + * @return {SystemCapabilityType} + */ + getSystemCapabilityType () { + return this.getObject(SystemCapabilityType, GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE); + } + + /** + * @param {Boolean} subscribe - Flag to subscribe to updates of the supplied service capability type. If true, the + * requester will be subscribed. If false, the requester will not be subscribed and be + * removed as a subscriber if it was previously subscribed. + * @return {GetSystemCapability} + */ + setSubscribe (subscribe) { + this.setParameter(GetSystemCapability.KEY_SUBSCRIBE, subscribe); + return this; + } + + /** + * @return {Boolean} + */ + getSubscribe () { + return this.getParameter(GetSystemCapability.KEY_SUBSCRIBE); + } +} + +GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE = 'systemCapabilityType'; +GetSystemCapability.KEY_SUBSCRIBE = 'subscribe'; + +export { GetSystemCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetSystemCapabilityResponse.js b/lib/js/src/rpc/messages/GetSystemCapabilityResponse.js new file mode 100644 index 00000000..af0a74a7 --- /dev/null +++ b/lib/js/src/rpc/messages/GetSystemCapabilityResponse.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; +import { SystemCapability } from '../structs/SystemCapability.js'; + +class GetSystemCapabilityResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetSystemCapability); + } + + /** + * @param {SystemCapability} capability - The systemCapabilityType identifies which data object exists in this + * struct. For example, if the SystemCapability Type is NAVIGATION then a + * "navigationCapability" should exist + * @return {GetSystemCapabilityResponse} + */ + setSystemCapability (capability) { + this.validateType(SystemCapability, capability); + this.setParameter(GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY, capability); + return this; + } + + /** + * @return {SystemCapability} + */ + getSystemCapability () { + return this.getObject(SystemCapability, GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY); + } +} + +GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY = 'systemCapability'; + +export { GetSystemCapabilityResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetVehicleData.js b/lib/js/src/rpc/messages/GetVehicleData.js new file mode 100644 index 00000000..132f6c2b --- /dev/null +++ b/lib/js/src/rpc/messages/GetVehicleData.js @@ -0,0 +1,561 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Non periodic vehicle data read request. + */ +class GetVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetVehicleData); + } + + /** + * @param {Boolean} gps - See GPSData + * @return {GetVehicleData} + */ + setGps (gps) { + this.setParameter(GetVehicleData.KEY_GPS, gps); + return this; + } + + /** + * @return {Boolean} + */ + getGps () { + return this.getParameter(GetVehicleData.KEY_GPS); + } + + /** + * @param {Boolean} speed - The vehicle speed in kilometers per hour + * @return {GetVehicleData} + */ + setSpeed (speed) { + this.setParameter(GetVehicleData.KEY_SPEED, speed); + return this; + } + + /** + * @return {Boolean} + */ + getSpeed () { + return this.getParameter(GetVehicleData.KEY_SPEED); + } + + /** + * @param {Boolean} rpm - The number of revolutions per minute of the engine + * @return {GetVehicleData} + */ + setRpm (rpm) { + this.setParameter(GetVehicleData.KEY_RPM, rpm); + return this; + } + + /** + * @return {Boolean} + */ + getRpm () { + return this.getParameter(GetVehicleData.KEY_RPM); + } + + /** + * @param {Boolean} level - The fuel level in the tank (percentage) + * @return {GetVehicleData} + */ + setFuelLevel (level) { + this.setParameter(GetVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + + /** + * @return {Boolean} + */ + getFuelLevel () { + return this.getParameter(GetVehicleData.KEY_FUEL_LEVEL); + } + + /** + * @param {Boolean} level_state - The fuel level state + * @return {GetVehicleData} + */ + setFuelLevel_State (level_state) { + this.setParameter(GetVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + + /** + * @return {Boolean} + */ + getFuelLevel_State () { + return this.getParameter(GetVehicleData.KEY_FUEL_LEVEL_STATE); + } + + /** + * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres + * @return {GetVehicleData} + */ + setInstantFuelConsumption (consumption) { + this.setParameter(GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + + /** + * @return {Boolean} + */ + getInstantFuelConsumption () { + return this.getParameter(GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + + /** + * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {GetVehicleData} + */ + setFuelRange (range) { + this.setParameter(GetVehicleData.KEY_FUEL_RANGE, range); + return this; + } + + /** + * @return {Boolean} + */ + getFuelRange () { + return this.getParameter(GetVehicleData.KEY_FUEL_RANGE); + } + + /** + * @param {Boolean} temperature - The external temperature in degrees celsius + * @return {GetVehicleData} + */ + setExternalTemperature (temperature) { + this.setParameter(GetVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Boolean} + */ + getExternalTemperature () { + return this.getParameter(GetVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + + /** + * @param {Boolean} signal - See TurnSignal + * @return {GetVehicleData} + */ + setTurnSignal (signal) { + this.setParameter(GetVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + + /** + * @return {Boolean} + */ + getTurnSignal () { + return this.getParameter(GetVehicleData.KEY_TURN_SIGNAL); + } + + /** + * @param {Boolean} vin - Vehicle identification number + * @return {GetVehicleData} + */ + setVin (vin) { + this.setParameter(GetVehicleData.KEY_VIN, vin); + return this; + } + + /** + * @return {Boolean} + */ + getVin () { + return this.getParameter(GetVehicleData.KEY_VIN); + } + + /** + * @param {Boolean} prndl - See PRNDL + * @return {GetVehicleData} + */ + setPrndl (prndl) { + this.setParameter(GetVehicleData.KEY_PRNDL, prndl); + return this; + } + + /** + * @return {Boolean} + */ + getPrndl () { + return this.getParameter(GetVehicleData.KEY_PRNDL); + } + + /** + * @param {Boolean} pressure - See TireStatus + * @return {GetVehicleData} + */ + setTirePressure (pressure) { + this.setParameter(GetVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + + /** + * @return {Boolean} + */ + getTirePressure () { + return this.getParameter(GetVehicleData.KEY_TIRE_PRESSURE); + } + + /** + * @param {Boolean} odometer - Odometer in km + * @return {GetVehicleData} + */ + setOdometer (odometer) { + this.setParameter(GetVehicleData.KEY_ODOMETER, odometer); + return this; + } + + /** + * @return {Boolean} + */ + getOdometer () { + return this.getParameter(GetVehicleData.KEY_ODOMETER); + } + + /** + * @param {Boolean} status - The status of the seat belts + * @return {GetVehicleData} + */ + setBeltStatus (status) { + this.setParameter(GetVehicleData.KEY_BELT_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getBeltStatus () { + return this.getParameter(GetVehicleData.KEY_BELT_STATUS); + } + + /** + * @param {Boolean} information - The body information including ignition status and internal temp + * @return {GetVehicleData} + */ + setBodyInformation (information) { + this.setParameter(GetVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + + /** + * @return {Boolean} + */ + getBodyInformation () { + return this.getParameter(GetVehicleData.KEY_BODY_INFORMATION); + } + + /** + * @param {Boolean} status - The device status including signal and battery strength + * @return {GetVehicleData} + */ + setDeviceStatus (status) { + this.setParameter(GetVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getDeviceStatus () { + return this.getParameter(GetVehicleData.KEY_DEVICE_STATUS); + } + + /** + * @param {Boolean} braking - The status of the brake pedal + * @return {GetVehicleData} + */ + setDriverBraking (braking) { + this.setParameter(GetVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + + /** + * @return {Boolean} + */ + getDriverBraking () { + return this.getParameter(GetVehicleData.KEY_DRIVER_BRAKING); + } + + /** + * @param {Boolean} status - The status of the wipers + * @return {GetVehicleData} + */ + setWiperStatus (status) { + this.setParameter(GetVehicleData.KEY_WIPER_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getWiperStatus () { + return this.getParameter(GetVehicleData.KEY_WIPER_STATUS); + } + + /** + * @param {Boolean} status - Status of the head lamps + * @return {GetVehicleData} + */ + setHeadLampStatus (status) { + this.setParameter(GetVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getHeadLampStatus () { + return this.getParameter(GetVehicleData.KEY_HEAD_LAMP_STATUS); + } + + /** + * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {GetVehicleData} + */ + setEngineTorque (torque) { + this.setParameter(GetVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + + /** + * @return {Boolean} + */ + getEngineTorque () { + return this.getParameter(GetVehicleData.KEY_ENGINE_TORQUE); + } + + /** + * @param {Boolean} position - Accelerator pedal position (percentage depressed) + * @return {GetVehicleData} + */ + setAccPedalPosition (position) { + this.setParameter(GetVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + + /** + * @return {Boolean} + */ + getAccPedalPosition () { + return this.getParameter(GetVehicleData.KEY_ACC_PEDAL_POSITION); + } + + /** + * @param {Boolean} angle - Current angle of the steering wheel (in deg) + * @return {GetVehicleData} + */ + setSteeringWheelAngle (angle) { + this.setParameter(GetVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + + /** + * @return {Boolean} + */ + getSteeringWheelAngle () { + return this.getParameter(GetVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + + /** + * @param {Boolean} life - The estimated percentage of remaining oil life of the engine. + * @return {GetVehicleData} + */ + setEngineOilLife (life) { + this.setParameter(GetVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + + /** + * @return {Boolean} + */ + getEngineOilLife () { + return this.getParameter(GetVehicleData.KEY_ENGINE_OIL_LIFE); + } + + /** + * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {GetVehicleData} + */ + setElectronicParkBrakeStatus (status) { + this.setParameter(GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getElectronicParkBrakeStatus () { + return this.getParameter(GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + + /** + * @param {Boolean} id - Parameter used by cloud apps to identify a head unit + * @return {GetVehicleData} + */ + setCloudAppVehicleID (id) { + this.setParameter(GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + + /** + * @return {Boolean} + */ + getCloudAppVehicleID () { + return this.getParameter(GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + + /** + * @param {Boolean} info - Emergency Call notification and confirmation data + * @return {GetVehicleData} + */ + setECallInfo (info) { + this.setParameter(GetVehicleData.KEY_E_CALL_INFO, info); + return this; + } + + /** + * @return {Boolean} + */ + getECallInfo () { + return this.getParameter(GetVehicleData.KEY_E_CALL_INFO); + } + + /** + * @param {Boolean} status - The status of the air bags + * @return {GetVehicleData} + */ + setAirbagStatus (status) { + this.setParameter(GetVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getAirbagStatus () { + return this.getParameter(GetVehicleData.KEY_AIRBAG_STATUS); + } + + /** + * @param {Boolean} event - Information related to an emergency event (and if it occurred) + * @return {GetVehicleData} + */ + setEmergencyEvent (event) { + this.setParameter(GetVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + + /** + * @return {Boolean} + */ + getEmergencyEvent () { + return this.getParameter(GetVehicleData.KEY_EMERGENCY_EVENT); + } + + /** + * @param {Boolean} status - The status modes of the cluster + * @return {GetVehicleData} + */ + setClusterModeStatus (status) { + this.setParameter(GetVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getClusterModeStatus () { + return this.getParameter(GetVehicleData.KEY_CLUSTER_MODE_STATUS); + } + + /** + * @param {Boolean} key - Information related to the MyKey feature + * @return {GetVehicleData} + */ + setMyKey (key) { + this.setParameter(GetVehicleData.KEY_MY_KEY, key); + return this; + } + + /** + * @return {Boolean} + */ + getMyKey () { + return this.getParameter(GetVehicleData.KEY_MY_KEY); + } +} + +GetVehicleData.KEY_GPS = 'gps'; +GetVehicleData.KEY_SPEED = 'speed'; +GetVehicleData.KEY_RPM = 'rpm'; +GetVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; +GetVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; +GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; +GetVehicleData.KEY_FUEL_RANGE = 'fuelRange'; +GetVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; +GetVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; +GetVehicleData.KEY_VIN = 'vin'; +GetVehicleData.KEY_PRNDL = 'prndl'; +GetVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; +GetVehicleData.KEY_ODOMETER = 'odometer'; +GetVehicleData.KEY_BELT_STATUS = 'beltStatus'; +GetVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; +GetVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; +GetVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; +GetVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; +GetVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; +GetVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; +GetVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; +GetVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; +GetVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; +GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; +GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; +GetVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; +GetVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; +GetVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; +GetVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; +GetVehicleData.KEY_MY_KEY = 'myKey'; + +export { GetVehicleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetVehicleDataResponse.js b/lib/js/src/rpc/messages/GetVehicleDataResponse.js new file mode 100644 index 00000000..bc9b35a0 --- /dev/null +++ b/lib/js/src/rpc/messages/GetVehicleDataResponse.js @@ -0,0 +1,595 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { AirbagStatus } from '../structs/AirbagStatus.js'; +import { ClusterModeStatus } from '../structs/ClusterModeStatus.js'; +import { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js'; +import { EmergencyEvent } from '../structs/EmergencyEvent.js'; +import { TurnSignal } from '../enums/TurnSignal.js'; +import { RpcResponse } from '../RpcResponse.js'; +import { HeadLampStatus } from '../structs/HeadLampStatus.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { DeviceStatus } from '../structs/DeviceStatus.js'; +import { WiperStatus } from '../enums/WiperStatus.js'; +import { ElectronicParkBrakeStatus } from '../enums/ElectronicParkBrakeStatus.js'; +import { MyKey } from '../structs/MyKey.js'; +import { GPSData } from '../structs/GPSData.js'; +import { PRNDL } from '../enums/PRNDL.js'; +import { FuelRange } from '../structs/FuelRange.js'; +import { ECallInfo } from '../structs/ECallInfo.js'; +import { BeltStatus } from '../structs/BeltStatus.js'; +import { ComponentVolumeStatus } from '../enums/ComponentVolumeStatus.js'; +import { BodyInformation } from '../structs/BodyInformation.js'; +import { TireStatus } from '../structs/TireStatus.js'; + +class GetVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetVehicleData); + } + + /** + * @param {GPSData} gps - See GPSData + * @return {GetVehicleDataResponse} + */ + setGps (gps) { + this.validateType(GPSData, gps); + this.setParameter(GetVehicleDataResponse.KEY_GPS, gps); + return this; + } + + /** + * @return {GPSData} + */ + getGps () { + return this.getObject(GPSData, GetVehicleDataResponse.KEY_GPS); + } + + /** + * @param {Number} speed - The vehicle speed in kilometers per hour + * @return {GetVehicleDataResponse} + */ + setSpeed (speed) { + this.setParameter(GetVehicleDataResponse.KEY_SPEED, speed); + return this; + } + + /** + * @return {Number} + */ + getSpeed () { + return this.getParameter(GetVehicleDataResponse.KEY_SPEED); + } + + /** + * @param {Number} rpm - The number of revolutions per minute of the engine + * @return {GetVehicleDataResponse} + */ + setRpm (rpm) { + this.setParameter(GetVehicleDataResponse.KEY_RPM, rpm); + return this; + } + + /** + * @return {Number} + */ + getRpm () { + return this.getParameter(GetVehicleDataResponse.KEY_RPM); + } + + /** + * @param {Number} level - The fuel level in the tank (percentage) + * @return {GetVehicleDataResponse} + */ + setFuelLevel (level) { + this.setParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL, level); + return this; + } + + /** + * @return {Number} + */ + getFuelLevel () { + return this.getParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL); + } + + /** + * @param {ComponentVolumeStatus} level_state - The fuel level state + * @return {GetVehicleDataResponse} + */ + setFuelLevel_State (level_state) { + this.validateType(ComponentVolumeStatus, level_state); + this.setParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + + /** + * @return {ComponentVolumeStatus} + */ + getFuelLevel_State () { + return this.getObject(ComponentVolumeStatus, GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE); + } + + /** + * @param {Number} consumption - The instantaneous fuel consumption in microlitres + * @return {GetVehicleDataResponse} + */ + setInstantFuelConsumption (consumption) { + this.setParameter(GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + + /** + * @return {Number} + */ + getInstantFuelConsumption () { + return this.getParameter(GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION); + } + + /** + * @param {FuelRange[]} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {GetVehicleDataResponse} + */ + setFuelRange (range) { + this.validateType(FuelRange, range, true); + this.setParameter(GetVehicleDataResponse.KEY_FUEL_RANGE, range); + return this; + } + + /** + * @return {FuelRange[]} + */ + getFuelRange () { + return this.getObject(FuelRange, GetVehicleDataResponse.KEY_FUEL_RANGE); + } + + /** + * @param {Number} temperature - The external temperature in degrees celsius + * @return {GetVehicleDataResponse} + */ + setExternalTemperature (temperature) { + this.setParameter(GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Number} + */ + getExternalTemperature () { + return this.getParameter(GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE); + } + + /** + * @param {TurnSignal} signal - See TurnSignal + * @return {GetVehicleDataResponse} + */ + setTurnSignal (signal) { + this.validateType(TurnSignal, signal); + this.setParameter(GetVehicleDataResponse.KEY_TURN_SIGNAL, signal); + return this; + } + + /** + * @return {TurnSignal} + */ + getTurnSignal () { + return this.getObject(TurnSignal, GetVehicleDataResponse.KEY_TURN_SIGNAL); + } + + /** + * @param {String} vin - Vehicle identification number + * @return {GetVehicleDataResponse} + */ + setVin (vin) { + this.setParameter(GetVehicleDataResponse.KEY_VIN, vin); + return this; + } + + /** + * @return {String} + */ + getVin () { + return this.getParameter(GetVehicleDataResponse.KEY_VIN); + } + + /** + * @param {PRNDL} prndl - See PRNDL + * @return {GetVehicleDataResponse} + */ + setPrndl (prndl) { + this.validateType(PRNDL, prndl); + this.setParameter(GetVehicleDataResponse.KEY_PRNDL, prndl); + return this; + } + + /** + * @return {PRNDL} + */ + getPrndl () { + return this.getObject(PRNDL, GetVehicleDataResponse.KEY_PRNDL); + } + + /** + * @param {TireStatus} pressure - See TireStatus + * @return {GetVehicleDataResponse} + */ + setTirePressure (pressure) { + this.validateType(TireStatus, pressure); + this.setParameter(GetVehicleDataResponse.KEY_TIRE_PRESSURE, pressure); + return this; + } + + /** + * @return {TireStatus} + */ + getTirePressure () { + return this.getObject(TireStatus, GetVehicleDataResponse.KEY_TIRE_PRESSURE); + } + + /** + * @param {Number} odometer - Odometer in km + * @return {GetVehicleDataResponse} + */ + setOdometer (odometer) { + this.setParameter(GetVehicleDataResponse.KEY_ODOMETER, odometer); + return this; + } + + /** + * @return {Number} + */ + getOdometer () { + return this.getParameter(GetVehicleDataResponse.KEY_ODOMETER); + } + + /** + * @param {BeltStatus} status - The status of the seat belts + * @return {GetVehicleDataResponse} + */ + setBeltStatus (status) { + this.validateType(BeltStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_BELT_STATUS, status); + return this; + } + + /** + * @return {BeltStatus} + */ + getBeltStatus () { + return this.getObject(BeltStatus, GetVehicleDataResponse.KEY_BELT_STATUS); + } + + /** + * @param {BodyInformation} information - The body information including power modes + * @return {GetVehicleDataResponse} + */ + setBodyInformation (information) { + this.validateType(BodyInformation, information); + this.setParameter(GetVehicleDataResponse.KEY_BODY_INFORMATION, information); + return this; + } + + /** + * @return {BodyInformation} + */ + getBodyInformation () { + return this.getObject(BodyInformation, GetVehicleDataResponse.KEY_BODY_INFORMATION); + } + + /** + * @param {DeviceStatus} status - The device status including signal and battery strength + * @return {GetVehicleDataResponse} + */ + setDeviceStatus (status) { + this.validateType(DeviceStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_DEVICE_STATUS, status); + return this; + } + + /** + * @return {DeviceStatus} + */ + getDeviceStatus () { + return this.getObject(DeviceStatus, GetVehicleDataResponse.KEY_DEVICE_STATUS); + } + + /** + * @param {VehicleDataEventStatus} braking - The status of the brake pedal + * @return {GetVehicleDataResponse} + */ + setDriverBraking (braking) { + this.validateType(VehicleDataEventStatus, braking); + this.setParameter(GetVehicleDataResponse.KEY_DRIVER_BRAKING, braking); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverBraking () { + return this.getObject(VehicleDataEventStatus, GetVehicleDataResponse.KEY_DRIVER_BRAKING); + } + + /** + * @param {WiperStatus} status - The status of the wipers + * @return {GetVehicleDataResponse} + */ + setWiperStatus (status) { + this.validateType(WiperStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_WIPER_STATUS, status); + return this; + } + + /** + * @return {WiperStatus} + */ + getWiperStatus () { + return this.getObject(WiperStatus, GetVehicleDataResponse.KEY_WIPER_STATUS); + } + + /** + * @param {HeadLampStatus} status - Status of the head lamps + * @return {GetVehicleDataResponse} + */ + setHeadLampStatus (status) { + this.validateType(HeadLampStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status); + return this; + } + + /** + * @return {HeadLampStatus} + */ + getHeadLampStatus () { + return this.getObject(HeadLampStatus, GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS); + } + + /** + * @param {Number} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {GetVehicleDataResponse} + */ + setEngineTorque (torque) { + this.setParameter(GetVehicleDataResponse.KEY_ENGINE_TORQUE, torque); + return this; + } + + /** + * @return {Number} + */ + getEngineTorque () { + return this.getParameter(GetVehicleDataResponse.KEY_ENGINE_TORQUE); + } + + /** + * @param {Number} position - Accelerator pedal position (percentage depressed) + * @return {GetVehicleDataResponse} + */ + setAccPedalPosition (position) { + this.setParameter(GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getAccPedalPosition () { + return this.getParameter(GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION); + } + + /** + * @param {Number} angle - Current angle of the steering wheel (in deg) + * @return {GetVehicleDataResponse} + */ + setSteeringWheelAngle (angle) { + this.setParameter(GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + + /** + * @return {Number} + */ + getSteeringWheelAngle () { + return this.getParameter(GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE); + } + + /** + * @param {Number} life - The estimated percentage of remaining oil life of the engine. + * @return {GetVehicleDataResponse} + */ + setEngineOilLife (life) { + this.setParameter(GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life); + return this; + } + + /** + * @return {Number} + */ + getEngineOilLife () { + return this.getParameter(GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE); + } + + /** + * @param {ElectronicParkBrakeStatus} status - The status of the park brake as provided by Electric Park Brake (EPB) + * system. + * @return {GetVehicleDataResponse} + */ + setElectronicParkBrakeStatus (status) { + this.validateType(ElectronicParkBrakeStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + + /** + * @return {ElectronicParkBrakeStatus} + */ + getElectronicParkBrakeStatus () { + return this.getObject(ElectronicParkBrakeStatus, GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + + /** + * @param {String} id - Parameter used by cloud apps to identify a head unit + * @return {GetVehicleDataResponse} + */ + setCloudAppVehicleID (id) { + this.setParameter(GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + + /** + * @return {String} + */ + getCloudAppVehicleID () { + return this.getParameter(GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID); + } + + /** + * @param {ECallInfo} info - Emergency Call notification and confirmation data + * @return {GetVehicleDataResponse} + */ + setECallInfo (info) { + this.validateType(ECallInfo, info); + this.setParameter(GetVehicleDataResponse.KEY_E_CALL_INFO, info); + return this; + } + + /** + * @return {ECallInfo} + */ + getECallInfo () { + return this.getObject(ECallInfo, GetVehicleDataResponse.KEY_E_CALL_INFO); + } + + /** + * @param {AirbagStatus} status - The status of the air bags + * @return {GetVehicleDataResponse} + */ + setAirbagStatus (status) { + this.validateType(AirbagStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_AIRBAG_STATUS, status); + return this; + } + + /** + * @return {AirbagStatus} + */ + getAirbagStatus () { + return this.getObject(AirbagStatus, GetVehicleDataResponse.KEY_AIRBAG_STATUS); + } + + /** + * @param {EmergencyEvent} event - Information related to an emergency event (and if it occurred) + * @return {GetVehicleDataResponse} + */ + setEmergencyEvent (event) { + this.validateType(EmergencyEvent, event); + this.setParameter(GetVehicleDataResponse.KEY_EMERGENCY_EVENT, event); + return this; + } + + /** + * @return {EmergencyEvent} + */ + getEmergencyEvent () { + return this.getObject(EmergencyEvent, GetVehicleDataResponse.KEY_EMERGENCY_EVENT); + } + + /** + * @param {ClusterModeStatus} status - The status modes of the cluster + * @return {GetVehicleDataResponse} + */ + setClusterModeStatus (status) { + this.validateType(ClusterModeStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + + /** + * @return {ClusterModeStatus} + */ + getClusterModeStatus () { + return this.getObject(ClusterModeStatus, GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS); + } + + /** + * @param {MyKey} key - Information related to the MyKey feature + * @return {GetVehicleDataResponse} + */ + setMyKey (key) { + this.validateType(MyKey, key); + this.setParameter(GetVehicleDataResponse.KEY_MY_KEY, key); + return this; + } + + /** + * @return {MyKey} + */ + getMyKey () { + return this.getObject(MyKey, GetVehicleDataResponse.KEY_MY_KEY); + } +} + +GetVehicleDataResponse.KEY_GPS = 'gps'; +GetVehicleDataResponse.KEY_SPEED = 'speed'; +GetVehicleDataResponse.KEY_RPM = 'rpm'; +GetVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel'; +GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; +GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; +GetVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange'; +GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; +GetVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal'; +GetVehicleDataResponse.KEY_VIN = 'vin'; +GetVehicleDataResponse.KEY_PRNDL = 'prndl'; +GetVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure'; +GetVehicleDataResponse.KEY_ODOMETER = 'odometer'; +GetVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus'; +GetVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation'; +GetVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus'; +GetVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking'; +GetVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus'; +GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; +GetVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque'; +GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; +GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; +GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; +GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; +GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; +GetVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo'; +GetVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus'; +GetVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent'; +GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; +GetVehicleDataResponse.KEY_MY_KEY = 'myKey'; + +export { GetVehicleDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetWayPoints.js b/lib/js/src/rpc/messages/GetWayPoints.js new file mode 100644 index 00000000..1e788796 --- /dev/null +++ b/lib/js/src/rpc/messages/GetWayPoints.js @@ -0,0 +1,71 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { WayPointType } from '../enums/WayPointType.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Request for getting waypoint/destination data. + */ +class GetWayPoints extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetWayPoints); + } + + /** + * @param {WayPointType} type - To request for either the destination only or for all waypoints including + * destination + * @return {GetWayPoints} + */ + setWayPointType (type) { + this.validateType(WayPointType, type); + this.setParameter(GetWayPoints.KEY_WAY_POINT_TYPE, type); + return this; + } + + /** + * @return {WayPointType} + */ + getWayPointType () { + return this.getObject(WayPointType, GetWayPoints.KEY_WAY_POINT_TYPE); + } +} + +GetWayPoints.KEY_WAY_POINT_TYPE = 'wayPointType'; + +export { GetWayPoints }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/GetWayPointsResponse.js b/lib/js/src/rpc/messages/GetWayPointsResponse.js new file mode 100644 index 00000000..4125d554 --- /dev/null +++ b/lib/js/src/rpc/messages/GetWayPointsResponse.js @@ -0,0 +1,67 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { LocationDetails } from '../structs/LocationDetails.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class GetWayPointsResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.GetWayPoints); + } + + /** + * @param {LocationDetails[]} points - See LocationDetails + * @return {GetWayPointsResponse} + */ + setWayPoints (points) { + this.validateType(LocationDetails, points, true); + this.setParameter(GetWayPointsResponse.KEY_WAY_POINTS, points); + return this; + } + + /** + * @return {LocationDetails[]} + */ + getWayPoints () { + return this.getObject(LocationDetails, GetWayPointsResponse.KEY_WAY_POINTS); + } +} + +GetWayPointsResponse.KEY_WAY_POINTS = 'wayPoints'; + +export { GetWayPointsResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ListFiles.js b/lib/js/src/rpc/messages/ListFiles.js new file mode 100644 index 00000000..6c52abf1 --- /dev/null +++ b/lib/js/src/rpc/messages/ListFiles.js @@ -0,0 +1,52 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Requests the current list of resident filenames for the registered app. Not supported on first generation SDL + * enabled vehicles. + */ +class ListFiles extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ListFiles); + } +} + + +export { ListFiles }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ListFilesResponse.js b/lib/js/src/rpc/messages/ListFilesResponse.js new file mode 100644 index 00000000..29a1bee9 --- /dev/null +++ b/lib/js/src/rpc/messages/ListFilesResponse.js @@ -0,0 +1,87 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * Returns the current list of resident filenames for the registered app along with the current space available Not + * supported on First generation SDL enabled vehicles. + */ +class ListFilesResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ListFiles); + } + + /** + * @param {String[]} filenames - An array of all filenames resident on the module for the given registered app. If + * omitted, then no files currently reside on the system. + * @return {ListFilesResponse} + */ + setFilenames (filenames) { + this.setParameter(ListFilesResponse.KEY_FILENAMES, filenames); + return this; + } + + /** + * @return {String[]} + */ + getFilenames () { + return this.getParameter(ListFilesResponse.KEY_FILENAMES); + } + + /** + * @param {Number} available - Provides the total local space available on the module for the registered app. + * @return {ListFilesResponse} + */ + setSpaceAvailable (available) { + this.setParameter(ListFilesResponse.KEY_SPACE_AVAILABLE, available); + return this; + } + + /** + * @return {Number} + */ + getSpaceAvailable () { + return this.getParameter(ListFilesResponse.KEY_SPACE_AVAILABLE); + } +} + +ListFilesResponse.KEY_FILENAMES = 'filenames'; +ListFilesResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable'; + +export { ListFilesResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnAppInterfaceUnregistered.js b/lib/js/src/rpc/messages/OnAppInterfaceUnregistered.js new file mode 100644 index 00000000..54fee94c --- /dev/null +++ b/lib/js/src/rpc/messages/OnAppInterfaceUnregistered.js @@ -0,0 +1,67 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { AppInterfaceUnregisteredReason } from '../enums/AppInterfaceUnregisteredReason.js'; +import { RpcNotification } from '../RpcNotification.js'; + +class OnAppInterfaceUnregistered extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnAppInterfaceUnregistered); + } + + /** + * @param {AppInterfaceUnregisteredReason} reason - See AppInterfaceUnregisteredReason + * @return {OnAppInterfaceUnregistered} + */ + setReason (reason) { + this.validateType(AppInterfaceUnregisteredReason, reason); + this.setParameter(OnAppInterfaceUnregistered.KEY_REASON, reason); + return this; + } + + /** + * @return {AppInterfaceUnregisteredReason} + */ + getReason () { + return this.getObject(AppInterfaceUnregisteredReason, OnAppInterfaceUnregistered.KEY_REASON); + } +} + +OnAppInterfaceUnregistered.KEY_REASON = 'reason'; + +export { OnAppInterfaceUnregistered }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnAppServiceData.js b/lib/js/src/rpc/messages/OnAppServiceData.js new file mode 100644 index 00000000..0274e210 --- /dev/null +++ b/lib/js/src/rpc/messages/OnAppServiceData.js @@ -0,0 +1,72 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { AppServiceData } from '../structs/AppServiceData.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * This notification includes the data that is updated from the specific service + */ +class OnAppServiceData extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnAppServiceData); + } + + /** + * @param {AppServiceData} data - Contains all the current data of the app service. The serviceType will link to + * which of the service data objects are included in this object (e.g. if the service + * type is MEDIA, the mediaServiceData param should be included). + * @return {OnAppServiceData} + */ + setServiceData (data) { + this.validateType(AppServiceData, data); + this.setParameter(OnAppServiceData.KEY_SERVICE_DATA, data); + return this; + } + + /** + * @return {AppServiceData} + */ + getServiceData () { + return this.getObject(AppServiceData, OnAppServiceData.KEY_SERVICE_DATA); + } +} + +OnAppServiceData.KEY_SERVICE_DATA = 'serviceData'; + +export { OnAppServiceData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnAudioPassThru.js b/lib/js/src/rpc/messages/OnAudioPassThru.js new file mode 100644 index 00000000..b27a5379 --- /dev/null +++ b/lib/js/src/rpc/messages/OnAudioPassThru.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Binary data is in binary part of hybrid msg + */ +class OnAudioPassThru extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnAudioPassThru); + } +} + + +export { OnAudioPassThru }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnButtonEvent.js b/lib/js/src/rpc/messages/OnButtonEvent.js new file mode 100644 index 00000000..1f05633b --- /dev/null +++ b/lib/js/src/rpc/messages/OnButtonEvent.js @@ -0,0 +1,107 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { ButtonName } from '../enums/ButtonName.js'; +import { ButtonEventMode } from '../enums/ButtonEventMode.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Notifies application of UP/DOWN events for buttons to which the application is subscribed. + */ +class OnButtonEvent extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnButtonEvent); + } + + /** + * @param {ButtonName} name - Defines the hard (physical) and soft (touchscreen) buttons available from the module + * @return {OnButtonEvent} + */ + setButtonName (name) { + this.validateType(ButtonName, name); + this.setParameter(OnButtonEvent.KEY_BUTTON_NAME, name); + return this; + } + + /** + * @return {ButtonName} + */ + getButtonName () { + return this.getObject(ButtonName, OnButtonEvent.KEY_BUTTON_NAME); + } + + /** + * @param {ButtonEventMode} mode - Indicates whether this is an UP or DOWN event. + * @return {OnButtonEvent} + */ + setButtonEventMode (mode) { + this.validateType(ButtonEventMode, mode); + this.setParameter(OnButtonEvent.KEY_BUTTON_EVENT_MODE, mode); + return this; + } + + /** + * @return {ButtonEventMode} + */ + getButtonEventMode () { + return this.getObject(ButtonEventMode, OnButtonEvent.KEY_BUTTON_EVENT_MODE); + } + + /** + * @param {Number} id - If ButtonName is "CUSTOM_BUTTON", this references the integer ID passed by a custom button. + * (e.g. softButton ID) + * @return {OnButtonEvent} + */ + setCustomButtonID (id) { + this.setParameter(OnButtonEvent.KEY_CUSTOM_BUTTON_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCustomButtonID () { + return this.getParameter(OnButtonEvent.KEY_CUSTOM_BUTTON_ID); + } +} + +OnButtonEvent.KEY_BUTTON_NAME = 'buttonName'; +OnButtonEvent.KEY_BUTTON_EVENT_MODE = 'buttonEventMode'; +OnButtonEvent.KEY_CUSTOM_BUTTON_ID = 'customButtonID'; + +export { OnButtonEvent }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnButtonPress.js b/lib/js/src/rpc/messages/OnButtonPress.js new file mode 100644 index 00000000..a65d0a3f --- /dev/null +++ b/lib/js/src/rpc/messages/OnButtonPress.js @@ -0,0 +1,107 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { ButtonPressMode } from '../enums/ButtonPressMode.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { ButtonName } from '../enums/ButtonName.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Notifies application of LONG/SHORT press events for buttons to which the application is subscribed. + */ +class OnButtonPress extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnButtonPress); + } + + /** + * @param {ButtonName} name - Defines the hard (physical) and soft (touchscreen) buttons available from the module + * @return {OnButtonPress} + */ + setButtonName (name) { + this.validateType(ButtonName, name); + this.setParameter(OnButtonPress.KEY_BUTTON_NAME, name); + return this; + } + + /** + * @return {ButtonName} + */ + getButtonName () { + return this.getObject(ButtonName, OnButtonPress.KEY_BUTTON_NAME); + } + + /** + * @param {ButtonPressMode} mode - Indicates whether this is a LONG or SHORT button press event. + * @return {OnButtonPress} + */ + setButtonPressMode (mode) { + this.validateType(ButtonPressMode, mode); + this.setParameter(OnButtonPress.KEY_BUTTON_PRESS_MODE, mode); + return this; + } + + /** + * @return {ButtonPressMode} + */ + getButtonPressMode () { + return this.getObject(ButtonPressMode, OnButtonPress.KEY_BUTTON_PRESS_MODE); + } + + /** + * @param {Number} id - If ButtonName is "CUSTOM_BUTTON", this references the integer ID passed by a custom button. + * (e.g. softButton ID) + * @return {OnButtonPress} + */ + setCustomButtonID (id) { + this.setParameter(OnButtonPress.KEY_CUSTOM_BUTTON_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCustomButtonID () { + return this.getParameter(OnButtonPress.KEY_CUSTOM_BUTTON_ID); + } +} + +OnButtonPress.KEY_BUTTON_NAME = 'buttonName'; +OnButtonPress.KEY_BUTTON_PRESS_MODE = 'buttonPressMode'; +OnButtonPress.KEY_CUSTOM_BUTTON_ID = 'customButtonID'; + +export { OnButtonPress }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnCommand.js b/lib/js/src/rpc/messages/OnCommand.js new file mode 100644 index 00000000..ac903e95 --- /dev/null +++ b/lib/js/src/rpc/messages/OnCommand.js @@ -0,0 +1,84 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { TriggerSource } from '../enums/TriggerSource.js'; +import { RpcNotification } from '../RpcNotification.js'; + +class OnCommand extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnCommand); + } + + /** + * @param {Number} id - Command ID, which is related to a specific menu entry + * @return {OnCommand} + */ + setCmdID (id) { + this.setParameter(OnCommand.KEY_CMD_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCmdID () { + return this.getParameter(OnCommand.KEY_CMD_ID); + } + + /** + * @param {TriggerSource} source - See TriggerSource + * @return {OnCommand} + */ + setTriggerSource (source) { + this.validateType(TriggerSource, source); + this.setParameter(OnCommand.KEY_TRIGGER_SOURCE, source); + return this; + } + + /** + * @return {TriggerSource} + */ + getTriggerSource () { + return this.getObject(TriggerSource, OnCommand.KEY_TRIGGER_SOURCE); + } +} + +OnCommand.KEY_CMD_ID = 'cmdID'; +OnCommand.KEY_TRIGGER_SOURCE = 'triggerSource'; + +export { OnCommand }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnDriverDistraction.js b/lib/js/src/rpc/messages/OnDriverDistraction.js new file mode 100644 index 00000000..fa5f6c02 --- /dev/null +++ b/lib/js/src/rpc/messages/OnDriverDistraction.js @@ -0,0 +1,109 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { DriverDistractionState } from '../enums/DriverDistractionState.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Provides driver distraction state to mobile applications + */ +class OnDriverDistraction extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnDriverDistraction); + } + + /** + * @param {DriverDistractionState} state - Current State of Driver Distraction + * @return {OnDriverDistraction} + */ + setState (state) { + this.validateType(DriverDistractionState, state); + this.setParameter(OnDriverDistraction.KEY_STATE, state); + return this; + } + + /** + * @return {DriverDistractionState} + */ + getState () { + return this.getObject(DriverDistractionState, OnDriverDistraction.KEY_STATE); + } + + /** + * @param {Boolean} enabled - If enabled, the lock screen will be able to be dismissed while connected to SDL, + * allowing users the ability to interact with the app. Dismissals should include a + * warning to the user and ensure that they are not the driver. + * @return {OnDriverDistraction} + */ + setLockScreenDismissalEnabled (enabled) { + this.setParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getLockScreenDismissalEnabled () { + return this.getParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED); + } + + /** + * @param {String} warning - Warning message to be displayed on the lock screen when dismissal is enabled. This + * warning should be used to ensure that the user is not the driver of the vehicle, ex. + * `Swipe down to dismiss, acknowledging that you are not the driver.`. This parameter + * must be present if "lockScreenDismissalEnabled" is set to true. + * @return {OnDriverDistraction} + */ + setLockScreenDismissalWarning (warning) { + this.setParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING, warning); + return this; + } + + /** + * @return {String} + */ + getLockScreenDismissalWarning () { + return this.getParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING); + } +} + +OnDriverDistraction.KEY_STATE = 'state'; +OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED = 'lockScreenDismissalEnabled'; +OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING = 'lockScreenDismissalWarning'; + +export { OnDriverDistraction }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnEncodedSyncPData.js b/lib/js/src/rpc/messages/OnEncodedSyncPData.js new file mode 100644 index 00000000..0a39b17d --- /dev/null +++ b/lib/js/src/rpc/messages/OnEncodedSyncPData.js @@ -0,0 +1,105 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Callback including encoded data of any SyncP packets that SYNC needs to send back to the mobile device. Legacy / v1 + * Protocol implementation; responds to EncodedSyncPData. *** DEPRECATED *** + */ +class OnEncodedSyncPData extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnEncodedSyncPData); + } + + /** + * @param {String[]} data - Contains base64 encoded string of SyncP packets. + * @return {OnEncodedSyncPData} + */ + setData (data) { + this.setParameter(OnEncodedSyncPData.KEY_DATA, data); + return this; + } + + /** + * @return {String[]} + */ + getData () { + return this.getParameter(OnEncodedSyncPData.KEY_DATA); + } + + /** + * @param {String} url - If blank, the SyncP data shall be forwarded to the app. If not blank, the SyncP data shall + * be forwarded to the provided URL. + * @return {OnEncodedSyncPData} + */ + setURL (url) { + this.setParameter(OnEncodedSyncPData.KEY_URL, url); + return this; + } + + /** + * @return {String} + */ + getURL () { + return this.getParameter(OnEncodedSyncPData.KEY_URL); + } + + /** + * @param {Number} timeout - If blank, the SyncP data shall be forwarded to the app. If not blank, the SyncP data + * shall be forwarded with the provided timeout in seconds. + * @return {OnEncodedSyncPData} + */ + setTimeout (timeout) { + this.setParameter(OnEncodedSyncPData.KEY_TIMEOUT, timeout); + return this; + } + + /** + * @return {Number} + */ + getTimeout () { + return this.getParameter(OnEncodedSyncPData.KEY_TIMEOUT); + } +} + +OnEncodedSyncPData.KEY_DATA = 'data'; +OnEncodedSyncPData.KEY_URL = 'URL'; +OnEncodedSyncPData.KEY_TIMEOUT = 'Timeout'; + +export { OnEncodedSyncPData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnHashChange.js b/lib/js/src/rpc/messages/OnHashChange.js new file mode 100644 index 00000000..e4de2f70 --- /dev/null +++ b/lib/js/src/rpc/messages/OnHashChange.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Notification containing an updated hashID which can be used over connection cycles (i.e. loss of connection, + * ignition cycles, etc.). Sent after initial registration and subsequently after any change in the calculated hash of + * all persisted app data. + */ +class OnHashChange extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnHashChange); + } + + /** + * @param {String} id - Calculated hash ID to be referenced during RegisterAppInterface. + * @return {OnHashChange} + */ + setHashID (id) { + this.setParameter(OnHashChange.KEY_HASH_ID, id); + return this; + } + + /** + * @return {String} + */ + getHashID () { + return this.getParameter(OnHashChange.KEY_HASH_ID); + } +} + +OnHashChange.KEY_HASH_ID = 'hashID'; + +export { OnHashChange }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnHmiStatus.js b/lib/js/src/rpc/messages/OnHmiStatus.js index 660de0cd..68404d08 100644 --- a/lib/js/src/rpc/messages/OnHmiStatus.js +++ b/lib/js/src/rpc/messages/OnHmiStatus.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,115 +31,114 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcNotification } from '../RpcNotification.js'; +import { SystemContext } from '../enums/SystemContext.js'; import { FunctionID } from '../enums/FunctionID.js'; -import { HMILevel } from '../enums/HMILevel.js'; +import { RpcNotification } from '../RpcNotification.js'; import { AudioStreamingState } from '../enums/AudioStreamingState.js'; +import { HMILevel } from '../enums/HMILevel.js'; import { VideoStreamingState } from '../enums/VideoStreamingState.js'; -import { SystemContext } from '../enums/SystemContext.js'; -class OnHmiStatus extends RpcNotification { +class OnHMIStatus extends RpcNotification { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.OnHMIStatus); } /** - * @param {HMILevel} hmiLevel - * @return {OnHmiStatus} - */ - setHMILevel (hmiLevel) { - this.validateType(HMILevel, hmiLevel); - - this.setParameter(OnHmiStatus.KEY_HMI_LEVEL, hmiLevel); + * @param {HMILevel} level - See HMILevel + * @return {OnHMIStatus} + */ + setHmiLevel (level) { + this.validateType(HMILevel, level); + this.setParameter(OnHMIStatus.KEY_HMI_LEVEL, level); return this; } /** - * @return {HMILevel} - */ - getHMILevel () { - return this.getObject(HMILevel, OnHmiStatus.KEY_HMI_LEVEL); + * @return {HMILevel} + */ + getHmiLevel () { + return this.getObject(HMILevel, OnHMIStatus.KEY_HMI_LEVEL); } /** - * @param {AudioStreamingState} audioStreamingState - * @return {OnHmiStatus} - */ - setAudioStreamingState (audioStreamingState) { - this.validateType(AudioStreamingState, audioStreamingState); - - this.setParameter(OnHmiStatus.KEY_AUDIO_STREAMING_STATE, audioStreamingState); + * @param {AudioStreamingState} state - See AudioStreamingState + * @return {OnHMIStatus} + */ + setAudioStreamingState (state) { + this.validateType(AudioStreamingState, state); + this.setParameter(OnHMIStatus.KEY_AUDIO_STREAMING_STATE, state); return this; } /** - * @return {AudioStreamingState} - */ + * @return {AudioStreamingState} + */ getAudioStreamingState () { - return this.getObject(AudioStreamingState, OnHmiStatus.KEY_AUDIO_STREAMING_STATE); + return this.getObject(AudioStreamingState, OnHMIStatus.KEY_AUDIO_STREAMING_STATE); } /** - * @param {SystemContext} systemContext - * @return {OnHmiStatus} - */ - setSystemContext (systemContext) { - this.validateType(SystemContext, systemContext); - - this.setParameter(OnHmiStatus.KEY_SYSTEM_CONTEXT, systemContext); + * @param {SystemContext} context - See SystemContext + * @return {OnHMIStatus} + */ + setSystemContext (context) { + this.validateType(SystemContext, context); + this.setParameter(OnHMIStatus.KEY_SYSTEM_CONTEXT, context); return this; } /** - * @return {SystemContext} - */ + * @return {SystemContext} + */ getSystemContext () { - return this.getObject(SystemContext, OnHmiStatus.KEY_SYSTEM_CONTEXT); + return this.getObject(SystemContext, OnHMIStatus.KEY_SYSTEM_CONTEXT); } /** - * @param {VideoStreamingState} videoStreamingState - * @return {OnHmiStatus} - */ - setVideoStreamingState (videoStreamingState) { - this.validateType(VideoStreamingState, videoStreamingState); - - this.setParameter(OnHmiStatus.KEY_VIDEO_STREAMING_STATE, videoStreamingState); + * @param {VideoStreamingState} state - See VideoStreamingState. If it is NOT_STREAMABLE, the app must stop + * streaming video to SDL Core(stop service). + * @return {OnHMIStatus} + */ + setVideoStreamingState (state) { + this.validateType(VideoStreamingState, state); + this.setParameter(OnHMIStatus.KEY_VIDEO_STREAMING_STATE, state); return this; } /** - * @return {VideoStreamingState} - */ + * @return {VideoStreamingState} + */ getVideoStreamingState () { - return this.getObject(VideoStreamingState, OnHmiStatus.KEY_VIDEO_STREAMING_STATE); + return this.getObject(VideoStreamingState, OnHMIStatus.KEY_VIDEO_STREAMING_STATE); } /** - * @param {Number} windowID - * @return {Show} - */ - setWindowID (windowID) { - this.setParameter(OnHmiStatus.KEY_WINDOW_ID, windowID); + * @param {Number} id - This is the unique ID assigned to the window that this RPC is intended. If this param is not + * included, it will be assumed that this request is specifically for the main window on the + * main display. See PredefinedWindows enum. + * @return {OnHMIStatus} + */ + setWindowID (id) { + this.setParameter(OnHMIStatus.KEY_WINDOW_ID, id); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getWindowID () { - return this.getParameter(OnHmiStatus.KEY_WINDOW_ID); + return this.getParameter(OnHMIStatus.KEY_WINDOW_ID); } } -OnHmiStatus.KEY_HMI_LEVEL = 'hmiLevel'; -OnHmiStatus.KEY_AUDIO_STREAMING_STATE = 'audioStreamingState'; -OnHmiStatus.KEY_SYSTEM_CONTEXT = 'systemContext'; -OnHmiStatus.KEY_VIDEO_STREAMING_STATE = 'videoStreamingState'; -OnHmiStatus.KEY_WINDOW_ID = 'windowID'; +OnHMIStatus.KEY_HMI_LEVEL = 'hmiLevel'; +OnHMIStatus.KEY_AUDIO_STREAMING_STATE = 'audioStreamingState'; +OnHMIStatus.KEY_SYSTEM_CONTEXT = 'systemContext'; +OnHMIStatus.KEY_VIDEO_STREAMING_STATE = 'videoStreamingState'; +OnHMIStatus.KEY_WINDOW_ID = 'windowID'; -export { OnHmiStatus }; +export { OnHMIStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnInteriorVehicleData.js b/lib/js/src/rpc/messages/OnInteriorVehicleData.js new file mode 100644 index 00000000..90967762 --- /dev/null +++ b/lib/js/src/rpc/messages/OnInteriorVehicleData.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { ModuleData } from '../structs/ModuleData.js'; +import { RpcNotification } from '../RpcNotification.js'; + +class OnInteriorVehicleData extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnInteriorVehicleData); + } + + /** + * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which + * data object exists in this struct. For example, if the moduleType is CLIMATE then a + * "climateControlData" should exist + * @return {OnInteriorVehicleData} + */ + setModuleData (data) { + this.validateType(ModuleData, data); + this.setParameter(OnInteriorVehicleData.KEY_MODULE_DATA, data); + return this; + } + + /** + * @return {ModuleData} + */ + getModuleData () { + return this.getObject(ModuleData, OnInteriorVehicleData.KEY_MODULE_DATA); + } +} + +OnInteriorVehicleData.KEY_MODULE_DATA = 'moduleData'; + +export { OnInteriorVehicleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnKeyboardInput.js b/lib/js/src/rpc/messages/OnKeyboardInput.js new file mode 100644 index 00000000..33c2fe63 --- /dev/null +++ b/lib/js/src/rpc/messages/OnKeyboardInput.js @@ -0,0 +1,90 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { KeyboardEvent } from '../enums/KeyboardEvent.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * On-screen keyboard event. Can be full string or individual keypresses depending on keyboard mode. + */ +class OnKeyboardInput extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnKeyboardInput); + } + + /** + * @param {KeyboardEvent} event - On-screen keyboard input data. + * @return {OnKeyboardInput} + */ + setEvent (event) { + this.validateType(KeyboardEvent, event); + this.setParameter(OnKeyboardInput.KEY_EVENT, event); + return this; + } + + /** + * @return {KeyboardEvent} + */ + getEvent () { + return this.getObject(KeyboardEvent, OnKeyboardInput.KEY_EVENT); + } + + /** + * @param {String} data - On-screen keyboard input data. For dynamic keypress events, this will be the current + * compounded string of entry text. For entry submission events, this will be the full text + * entry (this will always return regardless of the mode). For entry cancelled and entry + * aborted events, this data param will be omitted. + * @return {OnKeyboardInput} + */ + setData (data) { + this.setParameter(OnKeyboardInput.KEY_DATA, data); + return this; + } + + /** + * @return {String} + */ + getData () { + return this.getParameter(OnKeyboardInput.KEY_DATA); + } +} + +OnKeyboardInput.KEY_EVENT = 'event'; +OnKeyboardInput.KEY_DATA = 'data'; + +export { OnKeyboardInput }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnLanguageChange.js b/lib/js/src/rpc/messages/OnLanguageChange.js index b8612cbc..61250abc 100644 --- a/lib/js/src/rpc/messages/OnLanguageChange.js +++ b/lib/js/src/rpc/messages/OnLanguageChange.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,52 +31,50 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcNotification } from '../RpcNotification.js'; -import { Language } from '../enums/Language.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { Language } from '../enums/Language.js'; +import { RpcNotification } from '../RpcNotification.js'; class OnLanguageChange extends RpcNotification { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.OnLanguageChange); } /** - * @param {Language} language - * @return {OnLanguageChange} - */ + * @param {Language} language - Current SDL voice engine (VR+TTS) language + * @return {OnLanguageChange} + */ setLanguage (language) { this.validateType(Language, language); - this.setParameter(OnLanguageChange.KEY_LANGUAGE, language); return this; } /** - * @return {Language} - */ + * @return {Language} + */ getLanguage () { return this.getObject(Language, OnLanguageChange.KEY_LANGUAGE); } /** - * @param {Language} language - * @return {OnLanguageChange} - */ - setHMIDisplayLanguage (language) { + * @param {Language} language - Current display language + * @return {OnLanguageChange} + */ + setHmiDisplayLanguage (language) { this.validateType(Language, language); - this.setParameter(OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE, language); return this; } /** - * @return {Language} - */ - getHMIDisplayLanguage () { + * @return {Language} + */ + getHmiDisplayLanguage () { return this.getObject(Language, OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE); } } @@ -83,4 +82,4 @@ class OnLanguageChange extends RpcNotification { OnLanguageChange.KEY_LANGUAGE = 'language'; OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; -export { OnLanguageChange }; +export { OnLanguageChange }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnPermissionsChange.js b/lib/js/src/rpc/messages/OnPermissionsChange.js new file mode 100644 index 00000000..7144aa50 --- /dev/null +++ b/lib/js/src/rpc/messages/OnPermissionsChange.js @@ -0,0 +1,87 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { PermissionItem } from '../structs/PermissionItem.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Provides update to app of which policy-table-enabled functions are available + */ +class OnPermissionsChange extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnPermissionsChange); + } + + /** + * @param {PermissionItem[]} item - Change in permissions for a given set of RPCs + * @return {OnPermissionsChange} + */ + setPermissionItem (item) { + this.validateType(PermissionItem, item, true); + this.setParameter(OnPermissionsChange.KEY_PERMISSION_ITEM, item); + return this; + } + + /** + * @return {PermissionItem[]} + */ + getPermissionItem () { + return this.getObject(PermissionItem, OnPermissionsChange.KEY_PERMISSION_ITEM); + } + + /** + * @param {Boolean} encryption + * @return {OnPermissionsChange} + */ + setRequireEncryption (encryption) { + this.setParameter(OnPermissionsChange.KEY_REQUIRE_ENCRYPTION, encryption); + return this; + } + + /** + * @return {Boolean} + */ + getRequireEncryption () { + return this.getParameter(OnPermissionsChange.KEY_REQUIRE_ENCRYPTION); + } +} + +OnPermissionsChange.KEY_PERMISSION_ITEM = 'permissionItem'; +OnPermissionsChange.KEY_REQUIRE_ENCRYPTION = 'requireEncryption'; + +export { OnPermissionsChange }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnRCStatus.js b/lib/js/src/rpc/messages/OnRCStatus.js new file mode 100644 index 00000000..93b01ff5 --- /dev/null +++ b/lib/js/src/rpc/messages/OnRCStatus.js @@ -0,0 +1,107 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { ModuleData } from '../structs/ModuleData.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Issued by SDL to notify the application about remote control status change on SDL + */ +class OnRCStatus extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnRCStatus); + } + + /** + * @param {Boolean} allowed - If "true" - RC is allowed; if "false" - RC is disallowed. + * @return {OnRCStatus} + */ + setAllowed (allowed) { + this.setParameter(OnRCStatus.KEY_ALLOWED, allowed); + return this; + } + + /** + * @return {Boolean} + */ + getAllowed () { + return this.getParameter(OnRCStatus.KEY_ALLOWED); + } + + /** + * @param {ModuleData[]} modules - Contains a list (zero or more) of module types that are allocated to the + * application. + * @return {OnRCStatus} + */ + setAllocatedModules (modules) { + this.validateType(ModuleData, modules, true); + this.setParameter(OnRCStatus.KEY_ALLOCATED_MODULES, modules); + return this; + } + + /** + * @return {ModuleData[]} + */ + getAllocatedModules () { + return this.getObject(ModuleData, OnRCStatus.KEY_ALLOCATED_MODULES); + } + + /** + * @param {ModuleData[]} modules - Contains a list (zero or more) of module types that are free to access for the + * application. + * @return {OnRCStatus} + */ + setFreeModules (modules) { + this.validateType(ModuleData, modules, true); + this.setParameter(OnRCStatus.KEY_FREE_MODULES, modules); + return this; + } + + /** + * @return {ModuleData[]} + */ + getFreeModules () { + return this.getObject(ModuleData, OnRCStatus.KEY_FREE_MODULES); + } +} + +OnRCStatus.KEY_ALLOWED = 'allowed'; +OnRCStatus.KEY_ALLOCATED_MODULES = 'allocatedModules'; +OnRCStatus.KEY_FREE_MODULES = 'freeModules'; + +export { OnRCStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnSystemCapabilityUpdated.js b/lib/js/src/rpc/messages/OnSystemCapabilityUpdated.js new file mode 100644 index 00000000..6b2632d3 --- /dev/null +++ b/lib/js/src/rpc/messages/OnSystemCapabilityUpdated.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { SystemCapability } from '../structs/SystemCapability.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * A notification to inform the connected device that a specific system capability has changed. + */ +class OnSystemCapabilityUpdated extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnSystemCapabilityUpdated); + } + + /** + * @param {SystemCapability} capability - The system capability that has been updated + * @return {OnSystemCapabilityUpdated} + */ + setSystemCapability (capability) { + this.validateType(SystemCapability, capability); + this.setParameter(OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY, capability); + return this; + } + + /** + * @return {SystemCapability} + */ + getSystemCapability () { + return this.getObject(SystemCapability, OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY); + } +} + +OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY = 'systemCapability'; + +export { OnSystemCapabilityUpdated }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnSystemRequest.js b/lib/js/src/rpc/messages/OnSystemRequest.js new file mode 100644 index 00000000..aafef9f2 --- /dev/null +++ b/lib/js/src/rpc/messages/OnSystemRequest.js @@ -0,0 +1,178 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RequestType } from '../enums/RequestType.js'; +import { FileType } from '../enums/FileType.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * An asynchronous request from the system for specific data from the device or the cloud or response to a request from + * the device or cloud Binary data can be included in hybrid part of message for some requests (such as Authentication + * request responses) + */ +class OnSystemRequest extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnSystemRequest); + } + + /** + * @param {RequestType} type - The type of system request. + * @return {OnSystemRequest} + */ + setRequestType (type) { + this.validateType(RequestType, type); + this.setParameter(OnSystemRequest.KEY_REQUEST_TYPE, type); + return this; + } + + /** + * @return {RequestType} + */ + getRequestType () { + return this.getObject(RequestType, OnSystemRequest.KEY_REQUEST_TYPE); + } + + /** + * @param {String} type - This parameter is filled for supporting OEM proprietary data exchanges. + * @return {OnSystemRequest} + */ + setRequestSubType (type) { + this.setParameter(OnSystemRequest.KEY_REQUEST_SUB_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getRequestSubType () { + return this.getParameter(OnSystemRequest.KEY_REQUEST_SUB_TYPE); + } + + /** + * @param {String} url - Optional URL for HTTP requests. If blank, the binary data shall be forwarded to the app. If + * not blank, the binary data shall be forwarded to the url with a provided timeout in + * seconds. + * @return {OnSystemRequest} + */ + setUrl (url) { + this.setParameter(OnSystemRequest.KEY_URL, url); + return this; + } + + /** + * @return {String} + */ + getUrl () { + return this.getParameter(OnSystemRequest.KEY_URL); + } + + /** + * @param {Number} timeout - Optional timeout for HTTP requests Required if a URL is provided + * @return {OnSystemRequest} + */ + setTimeout (timeout) { + this.setParameter(OnSystemRequest.KEY_TIMEOUT, timeout); + return this; + } + + /** + * @return {Number} + */ + getTimeout () { + return this.getParameter(OnSystemRequest.KEY_TIMEOUT); + } + + /** + * @param {FileType} type - Optional file type (meant for HTTP file requests). + * @return {OnSystemRequest} + */ + setFileType (type) { + this.validateType(FileType, type); + this.setParameter(OnSystemRequest.KEY_FILE_TYPE, type); + return this; + } + + /** + * @return {FileType} + */ + getFileType () { + return this.getObject(FileType, OnSystemRequest.KEY_FILE_TYPE); + } + + /** + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {OnSystemRequest} + */ + setOffset (offset) { + this.setParameter(OnSystemRequest.KEY_OFFSET, offset); + return this; + } + + /** + * @return {Number} + */ + getOffset () { + return this.getParameter(OnSystemRequest.KEY_OFFSET); + } + + /** + * @param {Number} length - Optional length in bytes for resuming partial data chunks + * @return {OnSystemRequest} + */ + setLength (length) { + this.setParameter(OnSystemRequest.KEY_LENGTH, length); + return this; + } + + /** + * @return {Number} + */ + getLength () { + return this.getParameter(OnSystemRequest.KEY_LENGTH); + } +} + +OnSystemRequest.KEY_REQUEST_TYPE = 'requestType'; +OnSystemRequest.KEY_REQUEST_SUB_TYPE = 'requestSubType'; +OnSystemRequest.KEY_URL = 'url'; +OnSystemRequest.KEY_TIMEOUT = 'timeout'; +OnSystemRequest.KEY_FILE_TYPE = 'fileType'; +OnSystemRequest.KEY_OFFSET = 'offset'; +OnSystemRequest.KEY_LENGTH = 'length'; + +export { OnSystemRequest }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnTBTClientState.js b/lib/js/src/rpc/messages/OnTBTClientState.js new file mode 100644 index 00000000..4fc42898 --- /dev/null +++ b/lib/js/src/rpc/messages/OnTBTClientState.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { TBTState } from '../enums/TBTState.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Provides applications with notifications specific to the current TBT client status on the module + */ +class OnTBTClientState extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnTBTClientState); + } + + /** + * @param {TBTState} state - Current State of TBT client + * @return {OnTBTClientState} + */ + setState (state) { + this.validateType(TBTState, state); + this.setParameter(OnTBTClientState.KEY_STATE, state); + return this; + } + + /** + * @return {TBTState} + */ + getState () { + return this.getObject(TBTState, OnTBTClientState.KEY_STATE); + } +} + +OnTBTClientState.KEY_STATE = 'state'; + +export { OnTBTClientState }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnTouchEvent.js b/lib/js/src/rpc/messages/OnTouchEvent.js new file mode 100644 index 00000000..5ed585ef --- /dev/null +++ b/lib/js/src/rpc/messages/OnTouchEvent.js @@ -0,0 +1,89 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { TouchEvent } from '../structs/TouchEvent.js'; +import { TouchType } from '../enums/TouchType.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Notifies about touch events on the screen's prescribed area + */ +class OnTouchEvent extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnTouchEvent); + } + + /** + * @param {TouchType} type - The type of touch event. + * @return {OnTouchEvent} + */ + setType (type) { + this.validateType(TouchType, type); + this.setParameter(OnTouchEvent.KEY_TYPE, type); + return this; + } + + /** + * @return {TouchType} + */ + getType () { + return this.getObject(TouchType, OnTouchEvent.KEY_TYPE); + } + + /** + * @param {TouchEvent[]} event - List of all individual touches involved in this event. + * @return {OnTouchEvent} + */ + setEvent (event) { + this.validateType(TouchEvent, event, true); + this.setParameter(OnTouchEvent.KEY_EVENT, event); + return this; + } + + /** + * @return {TouchEvent[]} + */ + getEvent () { + return this.getObject(TouchEvent, OnTouchEvent.KEY_EVENT); + } +} + +OnTouchEvent.KEY_TYPE = 'type'; +OnTouchEvent.KEY_EVENT = 'event'; + +export { OnTouchEvent }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnVehicleData.js b/lib/js/src/rpc/messages/OnVehicleData.js new file mode 100644 index 00000000..40b769cc --- /dev/null +++ b/lib/js/src/rpc/messages/OnVehicleData.js @@ -0,0 +1,598 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { AirbagStatus } from '../structs/AirbagStatus.js'; +import { ClusterModeStatus } from '../structs/ClusterModeStatus.js'; +import { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js'; +import { EmergencyEvent } from '../structs/EmergencyEvent.js'; +import { TurnSignal } from '../enums/TurnSignal.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { HeadLampStatus } from '../structs/HeadLampStatus.js'; +import { DeviceStatus } from '../structs/DeviceStatus.js'; +import { WiperStatus } from '../enums/WiperStatus.js'; +import { RpcNotification } from '../RpcNotification.js'; +import { ElectronicParkBrakeStatus } from '../enums/ElectronicParkBrakeStatus.js'; +import { MyKey } from '../structs/MyKey.js'; +import { GPSData } from '../structs/GPSData.js'; +import { PRNDL } from '../enums/PRNDL.js'; +import { FuelRange } from '../structs/FuelRange.js'; +import { ECallInfo } from '../structs/ECallInfo.js'; +import { BeltStatus } from '../structs/BeltStatus.js'; +import { ComponentVolumeStatus } from '../enums/ComponentVolumeStatus.js'; +import { BodyInformation } from '../structs/BodyInformation.js'; +import { TireStatus } from '../structs/TireStatus.js'; + +/** + * Callback for the periodic and non periodic vehicle data read function. + */ +class OnVehicleData extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnVehicleData); + } + + /** + * @param {GPSData} gps - See GPSData + * @return {OnVehicleData} + */ + setGps (gps) { + this.validateType(GPSData, gps); + this.setParameter(OnVehicleData.KEY_GPS, gps); + return this; + } + + /** + * @return {GPSData} + */ + getGps () { + return this.getObject(GPSData, OnVehicleData.KEY_GPS); + } + + /** + * @param {Number} speed - The vehicle speed in kilometers per hour + * @return {OnVehicleData} + */ + setSpeed (speed) { + this.setParameter(OnVehicleData.KEY_SPEED, speed); + return this; + } + + /** + * @return {Number} + */ + getSpeed () { + return this.getParameter(OnVehicleData.KEY_SPEED); + } + + /** + * @param {Number} rpm - The number of revolutions per minute of the engine + * @return {OnVehicleData} + */ + setRpm (rpm) { + this.setParameter(OnVehicleData.KEY_RPM, rpm); + return this; + } + + /** + * @return {Number} + */ + getRpm () { + return this.getParameter(OnVehicleData.KEY_RPM); + } + + /** + * @param {Number} level - The fuel level in the tank (percentage) + * @return {OnVehicleData} + */ + setFuelLevel (level) { + this.setParameter(OnVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + + /** + * @return {Number} + */ + getFuelLevel () { + return this.getParameter(OnVehicleData.KEY_FUEL_LEVEL); + } + + /** + * @param {ComponentVolumeStatus} level_state - The fuel level state + * @return {OnVehicleData} + */ + setFuelLevel_State (level_state) { + this.validateType(ComponentVolumeStatus, level_state); + this.setParameter(OnVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + + /** + * @return {ComponentVolumeStatus} + */ + getFuelLevel_State () { + return this.getObject(ComponentVolumeStatus, OnVehicleData.KEY_FUEL_LEVEL_STATE); + } + + /** + * @param {Number} consumption - The instantaneous fuel consumption in microlitres + * @return {OnVehicleData} + */ + setInstantFuelConsumption (consumption) { + this.setParameter(OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + + /** + * @return {Number} + */ + getInstantFuelConsumption () { + return this.getParameter(OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + + /** + * @param {FuelRange[]} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {OnVehicleData} + */ + setFuelRange (range) { + this.validateType(FuelRange, range, true); + this.setParameter(OnVehicleData.KEY_FUEL_RANGE, range); + return this; + } + + /** + * @return {FuelRange[]} + */ + getFuelRange () { + return this.getObject(FuelRange, OnVehicleData.KEY_FUEL_RANGE); + } + + /** + * @param {Number} temperature - The external temperature in degrees celsius + * @return {OnVehicleData} + */ + setExternalTemperature (temperature) { + this.setParameter(OnVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Number} + */ + getExternalTemperature () { + return this.getParameter(OnVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + + /** + * @param {TurnSignal} signal - See TurnSignal + * @return {OnVehicleData} + */ + setTurnSignal (signal) { + this.validateType(TurnSignal, signal); + this.setParameter(OnVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + + /** + * @return {TurnSignal} + */ + getTurnSignal () { + return this.getObject(TurnSignal, OnVehicleData.KEY_TURN_SIGNAL); + } + + /** + * @param {String} vin - Vehicle identification number. + * @return {OnVehicleData} + */ + setVin (vin) { + this.setParameter(OnVehicleData.KEY_VIN, vin); + return this; + } + + /** + * @return {String} + */ + getVin () { + return this.getParameter(OnVehicleData.KEY_VIN); + } + + /** + * @param {PRNDL} prndl - See PRNDL + * @return {OnVehicleData} + */ + setPrndl (prndl) { + this.validateType(PRNDL, prndl); + this.setParameter(OnVehicleData.KEY_PRNDL, prndl); + return this; + } + + /** + * @return {PRNDL} + */ + getPrndl () { + return this.getObject(PRNDL, OnVehicleData.KEY_PRNDL); + } + + /** + * @param {TireStatus} pressure - See TireStatus + * @return {OnVehicleData} + */ + setTirePressure (pressure) { + this.validateType(TireStatus, pressure); + this.setParameter(OnVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + + /** + * @return {TireStatus} + */ + getTirePressure () { + return this.getObject(TireStatus, OnVehicleData.KEY_TIRE_PRESSURE); + } + + /** + * @param {Number} odometer - Odometer in km + * @return {OnVehicleData} + */ + setOdometer (odometer) { + this.setParameter(OnVehicleData.KEY_ODOMETER, odometer); + return this; + } + + /** + * @return {Number} + */ + getOdometer () { + return this.getParameter(OnVehicleData.KEY_ODOMETER); + } + + /** + * @param {BeltStatus} status - The status of the seat belts + * @return {OnVehicleData} + */ + setBeltStatus (status) { + this.validateType(BeltStatus, status); + this.setParameter(OnVehicleData.KEY_BELT_STATUS, status); + return this; + } + + /** + * @return {BeltStatus} + */ + getBeltStatus () { + return this.getObject(BeltStatus, OnVehicleData.KEY_BELT_STATUS); + } + + /** + * @param {BodyInformation} information - The body information including power modes + * @return {OnVehicleData} + */ + setBodyInformation (information) { + this.validateType(BodyInformation, information); + this.setParameter(OnVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + + /** + * @return {BodyInformation} + */ + getBodyInformation () { + return this.getObject(BodyInformation, OnVehicleData.KEY_BODY_INFORMATION); + } + + /** + * @param {DeviceStatus} status - The device status including signal and battery strength + * @return {OnVehicleData} + */ + setDeviceStatus (status) { + this.validateType(DeviceStatus, status); + this.setParameter(OnVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + + /** + * @return {DeviceStatus} + */ + getDeviceStatus () { + return this.getObject(DeviceStatus, OnVehicleData.KEY_DEVICE_STATUS); + } + + /** + * @param {VehicleDataEventStatus} braking - The status of the brake pedal + * @return {OnVehicleData} + */ + setDriverBraking (braking) { + this.validateType(VehicleDataEventStatus, braking); + this.setParameter(OnVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverBraking () { + return this.getObject(VehicleDataEventStatus, OnVehicleData.KEY_DRIVER_BRAKING); + } + + /** + * @param {WiperStatus} status - The status of the wipers + * @return {OnVehicleData} + */ + setWiperStatus (status) { + this.validateType(WiperStatus, status); + this.setParameter(OnVehicleData.KEY_WIPER_STATUS, status); + return this; + } + + /** + * @return {WiperStatus} + */ + getWiperStatus () { + return this.getObject(WiperStatus, OnVehicleData.KEY_WIPER_STATUS); + } + + /** + * @param {HeadLampStatus} status - Status of the head lamps + * @return {OnVehicleData} + */ + setHeadLampStatus (status) { + this.validateType(HeadLampStatus, status); + this.setParameter(OnVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + + /** + * @return {HeadLampStatus} + */ + getHeadLampStatus () { + return this.getObject(HeadLampStatus, OnVehicleData.KEY_HEAD_LAMP_STATUS); + } + + /** + * @param {Number} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {OnVehicleData} + */ + setEngineTorque (torque) { + this.setParameter(OnVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + + /** + * @return {Number} + */ + getEngineTorque () { + return this.getParameter(OnVehicleData.KEY_ENGINE_TORQUE); + } + + /** + * @param {Number} position - Accelerator pedal position (percentage depressed) + * @return {OnVehicleData} + */ + setAccPedalPosition (position) { + this.setParameter(OnVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getAccPedalPosition () { + return this.getParameter(OnVehicleData.KEY_ACC_PEDAL_POSITION); + } + + /** + * @param {Number} angle - Current angle of the steering wheel (in deg) + * @return {OnVehicleData} + */ + setSteeringWheelAngle (angle) { + this.setParameter(OnVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + + /** + * @return {Number} + */ + getSteeringWheelAngle () { + return this.getParameter(OnVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + + /** + * @param {Number} life - The estimated percentage of remaining oil life of the engine. + * @return {OnVehicleData} + */ + setEngineOilLife (life) { + this.setParameter(OnVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + + /** + * @return {Number} + */ + getEngineOilLife () { + return this.getParameter(OnVehicleData.KEY_ENGINE_OIL_LIFE); + } + + /** + * @param {ElectronicParkBrakeStatus} status - The status of the park brake as provided by Electric Park Brake (EPB) + * system. + * @return {OnVehicleData} + */ + setElectronicParkBrakeStatus (status) { + this.validateType(ElectronicParkBrakeStatus, status); + this.setParameter(OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + + /** + * @return {ElectronicParkBrakeStatus} + */ + getElectronicParkBrakeStatus () { + return this.getObject(ElectronicParkBrakeStatus, OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + + /** + * @param {String} id - Parameter used by cloud apps to identify a head unit + * @return {OnVehicleData} + */ + setCloudAppVehicleID (id) { + this.setParameter(OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + + /** + * @return {String} + */ + getCloudAppVehicleID () { + return this.getParameter(OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + + /** + * @param {ECallInfo} info - Emergency Call notification and confirmation data + * @return {OnVehicleData} + */ + setECallInfo (info) { + this.validateType(ECallInfo, info); + this.setParameter(OnVehicleData.KEY_E_CALL_INFO, info); + return this; + } + + /** + * @return {ECallInfo} + */ + getECallInfo () { + return this.getObject(ECallInfo, OnVehicleData.KEY_E_CALL_INFO); + } + + /** + * @param {AirbagStatus} status - The status of the air bags + * @return {OnVehicleData} + */ + setAirbagStatus (status) { + this.validateType(AirbagStatus, status); + this.setParameter(OnVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + + /** + * @return {AirbagStatus} + */ + getAirbagStatus () { + return this.getObject(AirbagStatus, OnVehicleData.KEY_AIRBAG_STATUS); + } + + /** + * @param {EmergencyEvent} event - Information related to an emergency event (and if it occurred) + * @return {OnVehicleData} + */ + setEmergencyEvent (event) { + this.validateType(EmergencyEvent, event); + this.setParameter(OnVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + + /** + * @return {EmergencyEvent} + */ + getEmergencyEvent () { + return this.getObject(EmergencyEvent, OnVehicleData.KEY_EMERGENCY_EVENT); + } + + /** + * @param {ClusterModeStatus} status - The status modes of the cluster + * @return {OnVehicleData} + */ + setClusterModeStatus (status) { + this.validateType(ClusterModeStatus, status); + this.setParameter(OnVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + + /** + * @return {ClusterModeStatus} + */ + getClusterModeStatus () { + return this.getObject(ClusterModeStatus, OnVehicleData.KEY_CLUSTER_MODE_STATUS); + } + + /** + * @param {MyKey} key - Information related to the MyKey feature + * @return {OnVehicleData} + */ + setMyKey (key) { + this.validateType(MyKey, key); + this.setParameter(OnVehicleData.KEY_MY_KEY, key); + return this; + } + + /** + * @return {MyKey} + */ + getMyKey () { + return this.getObject(MyKey, OnVehicleData.KEY_MY_KEY); + } +} + +OnVehicleData.KEY_GPS = 'gps'; +OnVehicleData.KEY_SPEED = 'speed'; +OnVehicleData.KEY_RPM = 'rpm'; +OnVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; +OnVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; +OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; +OnVehicleData.KEY_FUEL_RANGE = 'fuelRange'; +OnVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; +OnVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; +OnVehicleData.KEY_VIN = 'vin'; +OnVehicleData.KEY_PRNDL = 'prndl'; +OnVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; +OnVehicleData.KEY_ODOMETER = 'odometer'; +OnVehicleData.KEY_BELT_STATUS = 'beltStatus'; +OnVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; +OnVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; +OnVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; +OnVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; +OnVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; +OnVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; +OnVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; +OnVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; +OnVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; +OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; +OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; +OnVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; +OnVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; +OnVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; +OnVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; +OnVehicleData.KEY_MY_KEY = 'myKey'; + +export { OnVehicleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/OnWayPointChange.js b/lib/js/src/rpc/messages/OnWayPointChange.js new file mode 100644 index 00000000..68bc467c --- /dev/null +++ b/lib/js/src/rpc/messages/OnWayPointChange.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { LocationDetails } from '../structs/LocationDetails.js'; +import { RpcNotification } from '../RpcNotification.js'; + +/** + * Notification which provides the entire LocationDetails when there is a change to any waypoints or destination. + */ +class OnWayPointChange extends RpcNotification { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.OnWayPointChange); + } + + /** + * @param {LocationDetails[]} points - See LocationDetails + * @return {OnWayPointChange} + */ + setWayPoints (points) { + this.validateType(LocationDetails, points, true); + this.setParameter(OnWayPointChange.KEY_WAY_POINTS, points); + return this; + } + + /** + * @return {LocationDetails[]} + */ + getWayPoints () { + return this.getObject(LocationDetails, OnWayPointChange.KEY_WAY_POINTS); + } +} + +OnWayPointChange.KEY_WAY_POINTS = 'wayPoints'; + +export { OnWayPointChange }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PerformAppServiceInteraction.js b/lib/js/src/rpc/messages/PerformAppServiceInteraction.js new file mode 100644 index 00000000..1eb6e73b --- /dev/null +++ b/lib/js/src/rpc/messages/PerformAppServiceInteraction.js @@ -0,0 +1,119 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +class PerformAppServiceInteraction extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PerformAppServiceInteraction); + } + + /** + * @param {String} uri - Fully qualified URI based on a predetermined scheme provided by the app service. SDL makes + * no guarantee that this URI is correct. + * @return {PerformAppServiceInteraction} + */ + setServiceUri (uri) { + this.setParameter(PerformAppServiceInteraction.KEY_SERVICE_URI, uri); + return this; + } + + /** + * @return {String} + */ + getServiceUri () { + return this.getParameter(PerformAppServiceInteraction.KEY_SERVICE_URI); + } + + /** + * @param {String} id - The service ID that the app consumer wishes to send this URI. + * @return {PerformAppServiceInteraction} + */ + setServiceID (id) { + this.setParameter(PerformAppServiceInteraction.KEY_SERVICE_ID, id); + return this; + } + + /** + * @return {String} + */ + getServiceID () { + return this.getParameter(PerformAppServiceInteraction.KEY_SERVICE_ID); + } + + /** + * @param {String} app - This string is the appID of the app requesting the app service provider take the specific + * action. + * @return {PerformAppServiceInteraction} + */ + setOriginApp (app) { + this.setParameter(PerformAppServiceInteraction.KEY_ORIGIN_APP, app); + return this; + } + + /** + * @return {String} + */ + getOriginApp () { + return this.getParameter(PerformAppServiceInteraction.KEY_ORIGIN_APP); + } + + /** + * @param {Boolean} active - This flag signals the requesting consumer would like this service to become the active + * primary service of the destination's type. + * @return {PerformAppServiceInteraction} + */ + setRequestServiceActive (active) { + this.setParameter(PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE, active); + return this; + } + + /** + * @return {Boolean} + */ + getRequestServiceActive () { + return this.getParameter(PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE); + } +} + +PerformAppServiceInteraction.KEY_SERVICE_URI = 'serviceUri'; +PerformAppServiceInteraction.KEY_SERVICE_ID = 'serviceID'; +PerformAppServiceInteraction.KEY_ORIGIN_APP = 'originApp'; +PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE = 'requestServiceActive'; + +export { PerformAppServiceInteraction }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PerformAppServiceInteractionResponse.js b/lib/js/src/rpc/messages/PerformAppServiceInteractionResponse.js new file mode 100644 index 00000000..3a1e8696 --- /dev/null +++ b/lib/js/src/rpc/messages/PerformAppServiceInteractionResponse.js @@ -0,0 +1,65 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class PerformAppServiceInteractionResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PerformAppServiceInteraction); + } + + /** + * @param {String} result - The service can provide specific result strings to the consumer through this param. + * @return {PerformAppServiceInteractionResponse} + */ + setServiceSpecificResult (result) { + this.setParameter(PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT, result); + return this; + } + + /** + * @return {String} + */ + getServiceSpecificResult () { + return this.getParameter(PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT); + } +} + +PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT = 'serviceSpecificResult'; + +export { PerformAppServiceInteractionResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PerformAudioPassThru.js b/lib/js/src/rpc/messages/PerformAudioPassThru.js new file mode 100644 index 00000000..43cea934 --- /dev/null +++ b/lib/js/src/rpc/messages/PerformAudioPassThru.js @@ -0,0 +1,198 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { AudioType } from '../enums/AudioType.js'; +import { BitsPerSample } from '../enums/BitsPerSample.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { SamplingRate } from '../enums/SamplingRate.js'; + +/** + * Starts audio pass thru session + */ +class PerformAudioPassThru extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PerformAudioPassThru); + } + + /** + * @param {TTSChunk[]} prompt - The module will speak this prompt before opening the audio pass thru session. An + * array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. If omitted, then no initial prompt is spoken. + * @return {PerformAudioPassThru} + */ + setInitialPrompt (prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformAudioPassThru.KEY_INITIAL_PROMPT, prompt); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getInitialPrompt () { + return this.getObject(TTSChunk, PerformAudioPassThru.KEY_INITIAL_PROMPT); + } + + /** + * @param {String} text1 - First line of text displayed during audio capture. + * @return {PerformAudioPassThru} + */ + setAudioPassThruDisplayText1 (text1) { + this.setParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1, text1); + return this; + } + + /** + * @return {String} + */ + getAudioPassThruDisplayText1 () { + return this.getParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1); + } + + /** + * @param {String} text2 - Second line of text displayed during audio capture. + * @return {PerformAudioPassThru} + */ + setAudioPassThruDisplayText2 (text2) { + this.setParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2, text2); + return this; + } + + /** + * @return {String} + */ + getAudioPassThruDisplayText2 () { + return this.getParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2); + } + + /** + * @param {SamplingRate} rate - This value shall be allowed at 8 kHz or 16 or 22 or 44 kHz. + * @return {PerformAudioPassThru} + */ + setSamplingRate (rate) { + this.validateType(SamplingRate, rate); + this.setParameter(PerformAudioPassThru.KEY_SAMPLING_RATE, rate); + return this; + } + + /** + * @return {SamplingRate} + */ + getSamplingRate () { + return this.getObject(SamplingRate, PerformAudioPassThru.KEY_SAMPLING_RATE); + } + + /** + * @param {Number} duration - The maximum duration of audio recording in milliseconds. + * @return {PerformAudioPassThru} + */ + setMaxDuration (duration) { + this.setParameter(PerformAudioPassThru.KEY_MAX_DURATION, duration); + return this; + } + + /** + * @return {Number} + */ + getMaxDuration () { + return this.getParameter(PerformAudioPassThru.KEY_MAX_DURATION); + } + + /** + * @param {BitsPerSample} sample - Specifies the quality the audio is recorded. Currently 8 bit or 16 bit. + * @return {PerformAudioPassThru} + */ + setBitsPerSample (sample) { + this.validateType(BitsPerSample, sample); + this.setParameter(PerformAudioPassThru.KEY_BITS_PER_SAMPLE, sample); + return this; + } + + /** + * @return {BitsPerSample} + */ + getBitsPerSample () { + return this.getObject(BitsPerSample, PerformAudioPassThru.KEY_BITS_PER_SAMPLE); + } + + /** + * @param {AudioType} type - Specifies the type of audio data being requested. + * @return {PerformAudioPassThru} + */ + setAudioType (type) { + this.validateType(AudioType, type); + this.setParameter(PerformAudioPassThru.KEY_AUDIO_TYPE, type); + return this; + } + + /** + * @return {AudioType} + */ + getAudioType () { + return this.getObject(AudioType, PerformAudioPassThru.KEY_AUDIO_TYPE); + } + + /** + * @param {Boolean} audio - Defines if the current audio source should be muted during the APT session. If not, the + * audio source will play without interruption. If omitted, the value is set to true. + * @return {PerformAudioPassThru} + */ + setMuteAudio (audio) { + this.setParameter(PerformAudioPassThru.KEY_MUTE_AUDIO, audio); + return this; + } + + /** + * @return {Boolean} + */ + getMuteAudio () { + return this.getParameter(PerformAudioPassThru.KEY_MUTE_AUDIO); + } +} + +PerformAudioPassThru.KEY_INITIAL_PROMPT = 'initialPrompt'; +PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1 = 'audioPassThruDisplayText1'; +PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2 = 'audioPassThruDisplayText2'; +PerformAudioPassThru.KEY_SAMPLING_RATE = 'samplingRate'; +PerformAudioPassThru.KEY_MAX_DURATION = 'maxDuration'; +PerformAudioPassThru.KEY_BITS_PER_SAMPLE = 'bitsPerSample'; +PerformAudioPassThru.KEY_AUDIO_TYPE = 'audioType'; +PerformAudioPassThru.KEY_MUTE_AUDIO = 'muteAudio'; + +export { PerformAudioPassThru }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PerformAudioPassThruResponse.js b/lib/js/src/rpc/messages/PerformAudioPassThruResponse.js new file mode 100644 index 00000000..fa9f2c83 --- /dev/null +++ b/lib/js/src/rpc/messages/PerformAudioPassThruResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class PerformAudioPassThruResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PerformAudioPassThru); + } +} + + +export { PerformAudioPassThruResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PerformInteraction.js b/lib/js/src/rpc/messages/PerformInteraction.js new file mode 100644 index 00000000..87bf954e --- /dev/null +++ b/lib/js/src/rpc/messages/PerformInteraction.js @@ -0,0 +1,241 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { VrHelpItem } from '../structs/VrHelpItem.js'; +import { LayoutMode } from '../enums/LayoutMode.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { InteractionMode } from '../enums/InteractionMode.js'; + +/** + * Triggers an interaction (e.g. "Permit GPS?" - Yes, no, Always Allow). + */ +class PerformInteraction extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PerformInteraction); + } + + /** + * @param {String} text - Text to be displayed first. + * @return {PerformInteraction} + */ + setInitialText (text) { + this.setParameter(PerformInteraction.KEY_INITIAL_TEXT, text); + return this; + } + + /** + * @return {String} + */ + getInitialText () { + return this.getParameter(PerformInteraction.KEY_INITIAL_TEXT); + } + + /** + * @param {TTSChunk[]} prompt - This is the initial prompt spoken to the user at the start of an interaction. An + * array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. + * @return {PerformInteraction} + */ + setInitialPrompt (prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformInteraction.KEY_INITIAL_PROMPT, prompt); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getInitialPrompt () { + return this.getObject(TTSChunk, PerformInteraction.KEY_INITIAL_PROMPT); + } + + /** + * @param {InteractionMode} mode - See InteractionMode. + * @return {PerformInteraction} + */ + setInteractionMode (mode) { + this.validateType(InteractionMode, mode); + this.setParameter(PerformInteraction.KEY_INTERACTION_MODE, mode); + return this; + } + + /** + * @return {InteractionMode} + */ + getInteractionMode () { + return this.getObject(InteractionMode, PerformInteraction.KEY_INTERACTION_MODE); + } + + /** + * @param {Number[]} list - List of interaction choice set IDs to use with an interaction. + * @return {PerformInteraction} + */ + setInteractionChoiceSetIDList (list) { + this.setParameter(PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST, list); + return this; + } + + /** + * @return {Number[]} + */ + getInteractionChoiceSetIDList () { + return this.getParameter(PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST); + } + + /** + * @param {TTSChunk[]} prompt - Help text. This is the spoken string when a user speaks "help" when the interaction + * is occurring. An array of text chunks of type TTSChunk. See TTSChunk. The array must + * have at least one item. + * @return {PerformInteraction} + */ + setHelpPrompt (prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformInteraction.KEY_HELP_PROMPT, prompt); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getHelpPrompt () { + return this.getObject(TTSChunk, PerformInteraction.KEY_HELP_PROMPT); + } + + /** + * @param {TTSChunk[]} prompt - Timeout text. This text is spoken when a VR interaction times out. An array of text + * chunks of type TTSChunk. See TTSChunk. The array must have at least one item. + * @return {PerformInteraction} + */ + setTimeoutPrompt (prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformInteraction.KEY_TIMEOUT_PROMPT, prompt); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getTimeoutPrompt () { + return this.getObject(TTSChunk, PerformInteraction.KEY_TIMEOUT_PROMPT); + } + + /** + * @param {Number} timeout - Timeout in milliseconds. If omitted a standard value of 10000 milliseconds is used. + * Applies only to the menu portion of the interaction. The VR timeout will be handled by + * the platform. + * @return {PerformInteraction} + */ + setTimeout (timeout) { + this.setParameter(PerformInteraction.KEY_TIMEOUT, timeout); + return this; + } + + /** + * @return {Number} + */ + getTimeout () { + return this.getParameter(PerformInteraction.KEY_TIMEOUT); + } + + /** + * @param {VrHelpItem[]} help - Ability to send suggested VR Help Items to display on-screen during Perform + * Interaction. If omitted on supported displays, the default generated list of + * suggested choices shall be displayed. + * @return {PerformInteraction} + */ + setVrHelp (help) { + this.validateType(VrHelpItem, help, true); + this.setParameter(PerformInteraction.KEY_VR_HELP, help); + return this; + } + + /** + * @return {VrHelpItem[]} + */ + getVrHelp () { + return this.getObject(VrHelpItem, PerformInteraction.KEY_VR_HELP); + } + + /** + * @param {LayoutMode} layout - See LayoutMode. + * @return {PerformInteraction} + */ + setInteractionLayout (layout) { + this.validateType(LayoutMode, layout); + this.setParameter(PerformInteraction.KEY_INTERACTION_LAYOUT, layout); + return this; + } + + /** + * @return {LayoutMode} + */ + getInteractionLayout () { + return this.getObject(LayoutMode, PerformInteraction.KEY_INTERACTION_LAYOUT); + } + + /** + * @param {Number} id - An ID for this specific PerformInteraction to allow cancellation through the + * `CancelInteraction` RPC. + * @return {PerformInteraction} + */ + setCancelID (id) { + this.setParameter(PerformInteraction.KEY_CANCEL_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCancelID () { + return this.getParameter(PerformInteraction.KEY_CANCEL_ID); + } +} + +PerformInteraction.KEY_INITIAL_TEXT = 'initialText'; +PerformInteraction.KEY_INITIAL_PROMPT = 'initialPrompt'; +PerformInteraction.KEY_INTERACTION_MODE = 'interactionMode'; +PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST = 'interactionChoiceSetIDList'; +PerformInteraction.KEY_HELP_PROMPT = 'helpPrompt'; +PerformInteraction.KEY_TIMEOUT_PROMPT = 'timeoutPrompt'; +PerformInteraction.KEY_TIMEOUT = 'timeout'; +PerformInteraction.KEY_VR_HELP = 'vrHelp'; +PerformInteraction.KEY_INTERACTION_LAYOUT = 'interactionLayout'; +PerformInteraction.KEY_CANCEL_ID = 'cancelID'; + +export { PerformInteraction }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PerformInteractionResponse.js b/lib/js/src/rpc/messages/PerformInteractionResponse.js new file mode 100644 index 00000000..d0655bb6 --- /dev/null +++ b/lib/js/src/rpc/messages/PerformInteractionResponse.js @@ -0,0 +1,103 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { TriggerSource } from '../enums/TriggerSource.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class PerformInteractionResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PerformInteraction); + } + + /** + * @param {Number} id - ID of the choice that was selected in response to PerformInteraction. Only is valid if + * general result is "success:true". + * @return {PerformInteractionResponse} + */ + setChoiceID (id) { + this.setParameter(PerformInteractionResponse.KEY_CHOICE_ID, id); + return this; + } + + /** + * @return {Number} + */ + getChoiceID () { + return this.getParameter(PerformInteractionResponse.KEY_CHOICE_ID); + } + + /** + * @param {String} entry - Manually entered text selection, e.g. through keyboard Can be returned in lieu of + * choiceID, depending on trigger source + * @return {PerformInteractionResponse} + */ + setManualTextEntry (entry) { + this.setParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY, entry); + return this; + } + + /** + * @return {String} + */ + getManualTextEntry () { + return this.getParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY); + } + + /** + * @param {TriggerSource} source - See TriggerSource Only is valid if resultCode is SUCCESS. + * @return {PerformInteractionResponse} + */ + setTriggerSource (source) { + this.validateType(TriggerSource, source); + this.setParameter(PerformInteractionResponse.KEY_TRIGGER_SOURCE, source); + return this; + } + + /** + * @return {TriggerSource} + */ + getTriggerSource () { + return this.getObject(TriggerSource, PerformInteractionResponse.KEY_TRIGGER_SOURCE); + } +} + +PerformInteractionResponse.KEY_CHOICE_ID = 'choiceID'; +PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY = 'manualTextEntry'; +PerformInteractionResponse.KEY_TRIGGER_SOURCE = 'triggerSource'; + +export { PerformInteractionResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PublishAppService.js b/lib/js/src/rpc/messages/PublishAppService.js new file mode 100644 index 00000000..005396b0 --- /dev/null +++ b/lib/js/src/rpc/messages/PublishAppService.js @@ -0,0 +1,72 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { AppServiceManifest } from '../structs/AppServiceManifest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Registers a service offered by this app on the module. Subsequent calls with the same service type will update the + * manifest for that service. + */ +class PublishAppService extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PublishAppService); + } + + /** + * @param {AppServiceManifest} manifest - The manifest of the service that wishes to be published. If already + * published, the updated manifest for this service. + * @return {PublishAppService} + */ + setAppServiceManifest (manifest) { + this.validateType(AppServiceManifest, manifest); + this.setParameter(PublishAppService.KEY_APP_SERVICE_MANIFEST, manifest); + return this; + } + + /** + * @return {AppServiceManifest} + */ + getAppServiceManifest () { + return this.getObject(AppServiceManifest, PublishAppService.KEY_APP_SERVICE_MANIFEST); + } +} + +PublishAppService.KEY_APP_SERVICE_MANIFEST = 'appServiceManifest'; + +export { PublishAppService }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PublishAppServiceResponse.js b/lib/js/src/rpc/messages/PublishAppServiceResponse.js new file mode 100644 index 00000000..149b244a --- /dev/null +++ b/lib/js/src/rpc/messages/PublishAppServiceResponse.js @@ -0,0 +1,72 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; +import { AppServiceRecord } from '../structs/AppServiceRecord.js'; + +/** + * Response to the request to register a service offered by this app on the module + */ +class PublishAppServiceResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.PublishAppService); + } + + /** + * @param {AppServiceRecord} record - If the request was successful, this object will be the current status of the + * service record for the published service. This will include the Core supplied + * service ID. + * @return {PublishAppServiceResponse} + */ + setAppServiceRecord (record) { + this.validateType(AppServiceRecord, record); + this.setParameter(PublishAppServiceResponse.KEY_APP_SERVICE_RECORD, record); + return this; + } + + /** + * @return {AppServiceRecord} + */ + getAppServiceRecord () { + return this.getObject(AppServiceRecord, PublishAppServiceResponse.KEY_APP_SERVICE_RECORD); + } +} + +PublishAppServiceResponse.KEY_APP_SERVICE_RECORD = 'appServiceRecord'; + +export { PublishAppServiceResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PutFile.js b/lib/js/src/rpc/messages/PutFile.js index 3346995f..af234f0c 100644 --- a/lib/js/src/rpc/messages/PutFile.js +++ b/lib/js/src/rpc/messages/PutFile.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -34,10 +35,14 @@ import { RpcRequest } from '../RpcRequest.js'; import { FileType } from '../enums/FileType.js'; import { FunctionID } from '../enums/FunctionID.js'; +/** + * Used to push a binary data onto the module from a mobile device, such as icons and album art Not supported on first + * generation of SDL enabled modules. Binary data is in binary part of hybrid msg. + */ class PutFile extends RpcRequest { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.PutFile); @@ -46,133 +51,140 @@ class PutFile extends RpcRequest { // ------ Not part of the RPC spec itself ----- /** - * @param {Uint8Array} fileData - * @return {PutFile} - */ + * @param {Uint8Array} fileData + * @return {PutFile} + */ setFileData (fileData) { this.setBulkData(fileData); return this; } /** - * @return {Uint8Array} - */ + * @return {Uint8Array} + */ getFileData () { return this.getBulkData(); } // ----------------- END ----------------------- - /** - * @param {String} fileName - * @return {PutFile} - */ - setFileName (fileName) { - this.setParameter(PutFile.KEY_FILE_NAME, fileName); + * @param {String} name - File reference name. + * @return {PutFile} + */ + setFileName (name) { + this.setParameter(PutFile.KEY_FILE_NAME, name); return this; } /** - * @return {String} - */ + * @return {String} + */ getFileName () { return this.getParameter(PutFile.KEY_FILE_NAME); } /** - * @param {FileType} fileType - * @return {PutFile} - */ - setFileType (fileType) { - this.validateType(FileType, fileType); - this.setParameter(PutFile.KEY_FILE_TYPE, fileType); + * @param {FileType} type - Selected file type. + * @return {PutFile} + */ + setFileType (type) { + this.validateType(FileType, type); + this.setParameter(PutFile.KEY_FILE_TYPE, type); return this; } /** - * @return {FileType} - */ + * @return {FileType} + */ getFileType () { - return this.getObject(FileType, PutFile.KEY_MENU_PARAMS); + return this.getObject(FileType, PutFile.KEY_FILE_TYPE); } /** - * @param {Boolean} persistentFile - * @return {PutFile} - */ - setPersistentFile (persistentFile) { - this.setParameter(PutFile.KEY_PERSISTENT_FILE, persistentFile); + * @param {Boolean} file - Indicates if the file is meant to persist between sessions / ignition cycles. If set to + * TRUE, then the system will aim to persist this file through session / cycles. While files + * with this designation will have priority over others, they are subject to deletion by the + * system at any time. In the event of automatic deletion by the system, the app will + * receive a rejection and have to resend the file. If omitted, the value will be set to + * false. + * @return {PutFile} + */ + setPersistentFile (file) { + this.setParameter(PutFile.KEY_PERSISTENT_FILE, file); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getPersistentFile () { return this.getParameter(PutFile.KEY_PERSISTENT_FILE); } /** - * @param {Boolean} systemFile - * @return {PutFile} - */ - setSystemFile (systemFile) { - this.setParameter(PutFile.KEY_SYSTEM_FILE, systemFile); + * @param {Boolean} file - Indicates if the file is meant to be passed thru core to elsewhere on the system. If set + * to TRUE, then the system will instead pass the data thru as it arrives to a predetermined + * area outside of core. If omitted, the value will be set to false. + * @return {PutFile} + */ + setSystemFile (file) { + this.setParameter(PutFile.KEY_SYSTEM_FILE, file); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getSystemFile () { return this.getParameter(PutFile.KEY_SYSTEM_FILE); } /** - * @param {Number} offset - * @return {PutFile} - */ + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {PutFile} + */ setOffset (offset) { this.setParameter(PutFile.KEY_OFFSET, offset); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getOffset () { return this.getParameter(PutFile.KEY_OFFSET); } /** - * @param {Number} length - * @return {PutFile} - */ + * @param {Number} length - Optional length in bytes for resuming partial data chunks If offset is set to 0, then + * length is the total length of the file to be downloaded + * @return {PutFile} + */ setLength (length) { this.setParameter(PutFile.KEY_LENGTH, length); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getLength () { return this.getParameter(PutFile.KEY_LENGTH); } /** - * @param {Number} crc - * @return {PutFile} - */ - setCRC (crc) { + * @param {Number} crc - Additional CRC32 checksum to protect data integrity up to 512 Mbits + * @return {PutFile} + */ + setCrc (crc) { this.setParameter(PutFile.KEY_CRC, crc); return this; } /** - * @return {Number} - */ - getCRC () { + * @return {Number} + */ + getCrc () { return this.getParameter(PutFile.KEY_CRC); } } @@ -185,4 +197,4 @@ PutFile.KEY_OFFSET = 'offset'; PutFile.KEY_LENGTH = 'length'; PutFile.KEY_CRC = 'crc'; -export { PutFile }; +export { PutFile }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/PutFileResponse.js b/lib/js/src/rpc/messages/PutFileResponse.js index 25709690..18dd7cc7 100644 --- a/lib/js/src/rpc/messages/PutFileResponse.js +++ b/lib/js/src/rpc/messages/PutFileResponse.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,31 +31,35 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcResponse } from '../RpcResponse.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; +/** + * Response is sent, when the file data was copied (success case). Or when an error occurred. Not supported on first + * generation SDL enabled vehicles. + */ class PutFileResponse extends RpcResponse { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.PutFile); } - /** - * @param {Number} spaceAvailable - * @return {PutFileResponse} - */ - setSpaceAvailable (spaceAvailable) { - this.setParameter(PutFileResponse.KEY_SPACE_AVAILABLE, spaceAvailable); + * @param {Number} available - Provides the total local space available in SDL Core for the registered app. If the + * transfer has systemFile enabled, then the value will be set to 0 automatically. + * @return {PutFileResponse} + */ + setSpaceAvailable (available) { + this.setParameter(PutFileResponse.KEY_SPACE_AVAILABLE, available); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getSpaceAvailable () { return this.getParameter(PutFileResponse.KEY_SPACE_AVAILABLE); } @@ -62,4 +67,4 @@ class PutFileResponse extends RpcResponse { PutFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable'; -export { PutFileResponse }; +export { PutFileResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ReadDID.js b/lib/js/src/rpc/messages/ReadDID.js new file mode 100644 index 00000000..4a99669f --- /dev/null +++ b/lib/js/src/rpc/messages/ReadDID.js @@ -0,0 +1,85 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Non periodic vehicle data read request + */ +class ReadDID extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ReadDID); + } + + /** + * @param {Number} name - Name of ECU. + * @return {ReadDID} + */ + setEcuName (name) { + this.setParameter(ReadDID.KEY_ECU_NAME, name); + return this; + } + + /** + * @return {Number} + */ + getEcuName () { + return this.getParameter(ReadDID.KEY_ECU_NAME); + } + + /** + * @param {Number[]} location - Get raw data from vehicle data DID location(s) + * @return {ReadDID} + */ + setDidLocation (location) { + this.setParameter(ReadDID.KEY_DID_LOCATION, location); + return this; + } + + /** + * @return {Number[]} + */ + getDidLocation () { + return this.getParameter(ReadDID.KEY_DID_LOCATION); + } +} + +ReadDID.KEY_ECU_NAME = 'ecuName'; +ReadDID.KEY_DID_LOCATION = 'didLocation'; + +export { ReadDID }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ReadDIDResponse.js b/lib/js/src/rpc/messages/ReadDIDResponse.js new file mode 100644 index 00000000..b23b91a7 --- /dev/null +++ b/lib/js/src/rpc/messages/ReadDIDResponse.js @@ -0,0 +1,67 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { DIDResult } from '../structs/DIDResult.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ReadDIDResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ReadDID); + } + + /** + * @param {DIDResult[]} result - Array of requested DID results (with data if available). + * @return {ReadDIDResponse} + */ + setDidResult (result) { + this.validateType(DIDResult, result, true); + this.setParameter(ReadDIDResponse.KEY_DID_RESULT, result); + return this; + } + + /** + * @return {DIDResult[]} + */ + getDidResult () { + return this.getObject(DIDResult, ReadDIDResponse.KEY_DID_RESULT); + } +} + +ReadDIDResponse.KEY_DID_RESULT = 'didResult'; + +export { ReadDIDResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/RegisterAppInterface.js b/lib/js/src/rpc/messages/RegisterAppInterface.js index 94b19446..1072a4d2 100644 --- a/lib/js/src/rpc/messages/RegisterAppInterface.js +++ b/lib/js/src/rpc/messages/RegisterAppInterface.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,336 +31,352 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcRequest } from '../RpcRequest.js'; -import { SdlMsgVersion } from '../structs/SdlMsgVersion.js'; -import { TTSChunk } from '../structs/TTSChunk.js'; -import { DeviceInfo } from '../structs/DeviceInfo.js'; import { AppInfo } from '../structs/AppInfo.js'; import { TemplateColorScheme } from '../structs/TemplateColorScheme.js'; - -import { Language } from '../enums/Language.js'; -import { AppHMIType } from '../enums/AppHMIType.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { SdlMsgVersion } from '../structs/SdlMsgVersion.js'; +import { AppHMIType } from '../enums/AppHMIType.js'; +import { Language } from '../enums/Language.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { DeviceInfo } from '../structs/DeviceInfo.js'; +/** + * Establishes an interface with a mobile application. Before registerAppInterface no other commands will be + * accepted/executed. + */ class RegisterAppInterface extends RpcRequest { + /** + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.RegisterAppInterface); } /** - * @param {SdlMsgVersion} The max RPC Spec version supported by this library - * @return {RegisterAppInterface} - */ - setSdlMsgVersion (sdlMsgVersion) { - this.validateType(SdlMsgVersion, sdlMsgVersion); + * @param {String} fullAppId + * @return {RegisterAppInterface} + */ + setFullAppId (fullAppId) { + this.validateType(String, fullAppId); + + if (fullAppId !== null) { + fullAppId = fullAppId.toLowerCase(); + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, fullAppId); + let appID; + if (fullAppId.length <= RegisterAppInterface.APP_ID_MAX_LENGTH) { + appID = fullAppId; + } else { + appID = fullAppId.replace('-', '').substring(0, RegisterAppInterface.APP_ID_MAX_LENGTH); + } + this._setAppId(appID); + } else { + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, null); + } - this.setParameter(RegisterAppInterface.KEY_SDL_MSG_VERSION, sdlMsgVersion); return this; } /** - * @return {SdlMsgVersion} - */ - getSdlMsgVersion () { - return this.getObject(SdlMsgVersion, RegisterAppInterface.KEY_SDL_MSG_VERSION); + * @return {String} the app id + */ + getFullAppId () { + return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID); } + /** + * @param {String} appId - This method should not be accessed directly by developers. Only set the full ID and this + * param will be set. + * @return {RegisterAppInterface} + */ + _setAppId (appId) { + this.validateType(String, appId); + + this.setParameter(RegisterAppInterface.KEY_APP_ID, appId); + return this; + } /** - * @param {String} appName the name of the app that is registering - * @return {RegisterAppInterface} - */ - setAppName (appName) { - this.validateType(String, appName); + * @return {String} the app id + */ + getAppId () { + return this.getParameter(RegisterAppInterface.KEY_APP_ID); + } - this.setParameter(RegisterAppInterface.KEY_APP_NAME, appName); + /** + * @param {SdlMsgVersion} version - See SyncMsgVersion + * @return {RegisterAppInterface} + */ + setSdlMsgVersion (version) { + this.validateType(SdlMsgVersion, version); + this.setParameter(RegisterAppInterface.KEY_SDL_MSG_VERSION, version); return this; } /** - * @return {String} the app name - */ + * @return {SdlMsgVersion} + */ + getSdlMsgVersion () { + return this.getObject(SdlMsgVersion, RegisterAppInterface.KEY_SDL_MSG_VERSION); + } + + /** + * @param {String} name - The mobile application name, e.g. "My SDL App". Needs to be unique over all applications + * from the same device. May not be empty. May not start with a new line character. May not + * interfere with any name or synonym of previously registered applications from the same + * device and any predefined blacklist of words (global commands) Additional applications + * with the same name from the same device will be rejected. Only characters from char set + * @return {RegisterAppInterface} + */ + setAppName (name) { + this.setParameter(RegisterAppInterface.KEY_APP_NAME, name); + return this; + } + + /** + * @return {String} + */ getAppName () { return this.getParameter(RegisterAppInterface.KEY_APP_NAME); } /** - * @param {Array} ttsNames TTS string for VR recognition of the mobile application name, e.g. "My S D L App". - * Meant to overcome any failing on speech engine in properly pronouncing / understanding - * app name. Needs to be unique over all applications from the same device. May not be - * empty. May not start with a new line character. Only characters from char set - * @return {RegisterAppInterface} - */ - setTtsName (ttsNames) { - this.setParameter(RegisterAppInterface.KEY_TTS_NAME, ttsNames); + * @param {TTSChunk[]} name - TTS string for VR recognition of the mobile application name, e.g. "My S D L App". + * Meant to overcome any failing on speech engine in properly pronouncing / understanding + * app name. Needs to be unique over all applications from the same device. May not be + * empty. May not start with a new line character. Only characters from char set + * @return {RegisterAppInterface} + */ + setTtsName (name) { + this.validateType(TTSChunk, name, true); + this.setParameter(RegisterAppInterface.KEY_TTS_NAME, name); return this; } /** - * @return {Array} - */ + * @return {TTSChunk[]} + */ getTtsName () { return this.getObject(TTSChunk, RegisterAppInterface.KEY_TTS_NAME); } /** - * @param {String} ngnppName Provides an abbreviated version of the app name (if needed), that will be displayed - * on the NGN media screen. If not provided, the appName is used instead (and - * will be truncated if too long)Only characters from char set. - * @return {RegisterAppInterface} - */ - setNgnMediaScreenAppName (ngnppName) { - this.validateType(String, ngnppName); - - this.setParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME, ngnppName); + * @param {String} name - Provides an abbreviated version of the app name (if needed), that will be displayed on the + * NGN media screen. If not provided, the appName is used instead (and will be truncated if + * too long) Only characters from char set + * @return {RegisterAppInterface} + */ + setNgnMediaScreenAppName (name) { + this.setParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME, name); return this; } /** - * @return {String} an abbreviated version of the app name - */ + * @return {String} + */ getNgnMediaScreenAppName () { return this.getParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME); } /** - * @param {Array} vrSynonyms Defines an additional voice recognition command. May not - * interfere with any app name of previously registered applications - * from the same device and any predefined blacklist of words (global - * commands)Only characters from char set - * @return {RegisterAppInterface} - */ - setVrSynonyms (vrSynonyms) { - this.setParameter(RegisterAppInterface.KEY_VR_SYNONYMS, vrSynonyms); + * @param {String[]} synonyms - Defines an additional voice recognition command. May not interfere with any app name + * of previously registered applications from the same device and any predefined + * blacklist of words (global commands) Only characters from char set + * @return {RegisterAppInterface} + */ + setVrSynonyms (synonyms) { + this.setParameter(RegisterAppInterface.KEY_VR_SYNONYMS, synonyms); return this; } /** - * @return {Array} - */ + * @return {String[]} + */ getVrSynonyms () { return this.getParameter(RegisterAppInterface.KEY_VR_SYNONYMS); } /** - * @param {Boolean} isMediaApplication Indicates if the application is a media or a non-media application. - * Only media applications will be able to stream audio to the module - * that is audible outside of the BT media source. - * @return {RegisterAppInterface} - */ - setIsMediaApplication (isMediaApplication) { - this.setParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION, isMediaApplication); + * @param {Boolean} application - Indicates if the application is a media or a non-media application. Only media + * applications will be able to stream audio to the module that is audible outside of + * the BT media source. + * @return {RegisterAppInterface} + */ + setIsMediaApplication (application) { + this.setParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION, application); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getIsMediaApplication () { return this.getParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION); } /** - * @param {Language} languageDesired - * @return {RegisterAppInterface} - */ - setLanguageDesired (languageDesired) { - this.validateType(Language, languageDesired); - - this.setParameter(RegisterAppInterface.KEY_LANGUAGE_DESIRED, languageDesired); + * @param {Language} desired - See Language Current app's expected VR+TTS language If there is a mismatch with the + * module, the app will be able to change this registration with changeRegistration + * prior to app being brought into focus. + * @return {RegisterAppInterface} + */ + setLanguageDesired (desired) { + this.validateType(Language, desired); + this.setParameter(RegisterAppInterface.KEY_LANGUAGE_DESIRED, desired); return this; } /** - * @return {Language} - */ + * @return {Language} + */ getLanguageDesired () { return this.getObject(Language, RegisterAppInterface.KEY_LANGUAGE_DESIRED); } - /** - * @param {Language} hmiDisplayLanguageDesired - * @return {RegisterAppInterface} - */ - setHmiDisplayLanguageDesired (hmiDisplayLanguageDesired) { - this.validateType(Language, hmiDisplayLanguageDesired); - - this.setParameter(RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED, hmiDisplayLanguageDesired); + * @param {Language} desired - See Language Current app's expected display language If there is a mismatch with the + * module, the app will be able to change this registration with changeRegistration + * prior to app being brought into focus. + * @return {RegisterAppInterface} + */ + setHmiDisplayLanguageDesired (desired) { + this.validateType(Language, desired); + this.setParameter(RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED, desired); return this; } /** - * @return {Language} - */ + * @return {Language} + */ getHmiDisplayLanguageDesired () { return this.getObject(Language, RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED); } - /** - * @param {Array} appHMIType - * @return {RegisterAppInterface} - */ - setAppHmiType (appHMIType) { - // TODO make validate type accept arrays - // this.validateType(AppHMIType, appHMIType); - - this.setParameter(RegisterAppInterface.KEY_APP_HMI_TYPE, appHMIType); + * @param {AppHMIType[]} type - See AppHMIType List of all applicable app HMI types stating which HMI + * classifications to be given to the app. + * @return {RegisterAppInterface} + */ + setAppHMIType (type) { + this.validateType(AppHMIType, type, true); + this.setParameter(RegisterAppInterface.KEY_APP_HMI_TYPE, type); return this; } /** - * @return {Array} - */ - getAppHmiType () { + * @return {AppHMIType[]} + */ + getAppHMIType () { return this.getObject(AppHMIType, RegisterAppInterface.KEY_APP_HMI_TYPE); } /** - * @param {String} hashID the hash ID - * @return {RegisterAppInterface} - */ - setHashID (hashID) { - this.validateType(String, hashID); - - this.setParameter(RegisterAppInterface.KEY_HASH_ID, hashID); + * @param {String} id - ID used to uniquely identify current state of all app data that can persist through + * connection cycles (e.g. ignition cycles). This registered data (commands, submenus, choice + * sets, etc.) can be reestablished without needing to explicitly reregister each piece. If + * omitted, then the previous state of an app's commands, etc. will not be restored. When + * sending hashID, all RegisterAppInterface parameters should still be provided (e.g. ttsName, + * etc.). + * @return {RegisterAppInterface} + */ + setHashID (id) { + this.setParameter(RegisterAppInterface.KEY_HASH_ID, id); return this; } /** - * @return {String} the hash ID - */ + * @return {String} + */ getHashID () { return this.getParameter(RegisterAppInterface.KEY_HASH_ID); } /** - * @param {DeviceInfo} deviceInfo + * @param {DeviceInfo} info - See DeviceInfo. * @return {RegisterAppInterface} */ - setDeviceInfo (deviceInfo) { - this.validateType(DeviceInfo, deviceInfo); - - this.setParameter(RegisterAppInterface.KEY_DEVICE_INFO, deviceInfo); + setDeviceInfo (info) { + this.validateType(DeviceInfo, info); + this.setParameter(RegisterAppInterface.KEY_DEVICE_INFO, info); return this; } /** - * @return {DeviceInfo} - */ + * @return {DeviceInfo} + */ getDeviceInfo () { return this.getObject(DeviceInfo, RegisterAppInterface.KEY_DEVICE_INFO); } - /** - * @param {String} appName This method should not be accessed directly by developers. Only set the full ID and this param will be set. - * @return {RegisterAppInterface} - */ - _setAppId (appId) { - this.validateType(String, appId); - - this.setParameter(RegisterAppInterface.KEY_APP_ID, appId); - return this; - } - - /** - * @return {String} the app id - */ - getAppId () { - return this.getParameter(RegisterAppInterface.KEY_APP_ID); - } - - /** - * @param {String} fullAppId - * @return {RegisterAppInterface} - */ - setFullAppId (fullAppId) { - this.validateType(String, fullAppId); - - if (fullAppId !== null) { - fullAppId = fullAppId.toLowerCase(); - this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, fullAppId); - let appId; - if (fullAppId.length <= RegisterAppInterface.APP_ID_MAX_LENGTH) { - appId = fullAppId; - } else { - appId = fullAppId.replace('-', '').substring(0, RegisterAppInterface.APP_ID_MAX_LENGTH); - } - this._setAppId(appId); - } else { - this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, null); - } - + * @param {String} id - ID used to validate app with policy table entries + * @return {RegisterAppInterface} + */ + setFullAppID (id) { + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, id); return this; } /** - * @return {String} the app id - */ - getFullAppId () { + * @return {String} + */ + getFullAppID () { return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID); } - /** - * @param {AppInfo} appInfo + * @param {AppInfo} info - See AppInfo. * @return {RegisterAppInterface} */ - setAppInfo (appInfo) { - this.validateType(AppInfo, appInfo); - - this.setParameter(RegisterAppInterface.KEY_APP_INFO, appInfo); + setAppInfo (info) { + this.validateType(AppInfo, info); + this.setParameter(RegisterAppInterface.KEY_APP_INFO, info); return this; } /** - * @return {AppInfo} - */ + * @return {AppInfo} + */ getAppInfo () { return this.getObject(AppInfo, RegisterAppInterface.KEY_APP_INFO); } /** - * @param {TemplateColorScheme} dayColorScheme + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. * @return {RegisterAppInterface} */ - setDayColorScheme (dayColorScheme) { - this.validateType(TemplateColorScheme, dayColorScheme); - - this.setParameter(RegisterAppInterface.KEY_DAY_COLOR_SCHEME, dayColorScheme); + setDayColorScheme (scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(RegisterAppInterface.KEY_DAY_COLOR_SCHEME, scheme); return this; } /** - * @return {TemplateColorScheme} - */ + * @return {TemplateColorScheme} + */ getDayColorScheme () { return this.getObject(TemplateColorScheme, RegisterAppInterface.KEY_DAY_COLOR_SCHEME); } /** - * @param {TemplateColorScheme} nightColorScheme + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. * @return {RegisterAppInterface} */ - setNightColorScheme (nightColorScheme) { - this.validateType(TemplateColorScheme, nightColorScheme); - - this.setParameter(RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME, nightColorScheme); + setNightColorScheme (scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME, scheme); return this; } /** - * @return {TemplateColorScheme} - */ + * @return {TemplateColorScheme} + */ getNightColorScheme () { return this.getObject(TemplateColorScheme, RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME); } } -RegisterAppInterface.KEY_SYNC_MSG_VERSION = 'syncMsgVersion'; RegisterAppInterface.KEY_SDL_MSG_VERSION = 'syncMsgVersion'; RegisterAppInterface.KEY_APP_NAME = 'appName'; RegisterAppInterface.KEY_TTS_NAME = 'ttsName'; @@ -378,4 +395,4 @@ RegisterAppInterface.KEY_DAY_COLOR_SCHEME = 'dayColorScheme'; RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme'; RegisterAppInterface.APP_ID_MAX_LENGTH = 10; -export { RegisterAppInterface }; +export { RegisterAppInterface }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/RegisterAppInterfaceResponse.js b/lib/js/src/rpc/messages/RegisterAppInterfaceResponse.js index af742b39..3530ada6 100644 --- a/lib/js/src/rpc/messages/RegisterAppInterfaceResponse.js +++ b/lib/js/src/rpc/messages/RegisterAppInterfaceResponse.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,367 +31,358 @@ * POSSIBILITY OF SUCH DAMAGE. */ +import { SoftButtonCapabilities } from '../structs/SoftButtonCapabilities.js'; import { RpcResponse } from '../RpcResponse.js'; +import { FunctionID } from '../enums/FunctionID.js'; import { SdlMsgVersion } from '../structs/SdlMsgVersion.js'; -import { DisplayCapabilities } from '../structs/DisplayCapabilities.js'; -import { ButtonCapabilities } from '../structs/ButtonCapabilities.js'; -import { SoftButtonCapabilities } from '../structs/SoftButtonCapabilities.js'; +import { PrerecordedSpeech } from '../enums/PrerecordedSpeech.js'; +import { SpeechCapabilities } from '../enums/SpeechCapabilities.js'; import { PresetBankCapabilities } from '../structs/PresetBankCapabilities.js'; import { VehicleType } from '../structs/VehicleType.js'; -import { Language } from '../enums/Language.js'; import { HmiZoneCapabilities } from '../enums/HmiZoneCapabilities.js'; -import { SpeechCapabilities } from '../enums/SpeechCapabilities.js'; -import { PrerecordedSpeech } from '../enums/PrerecordedSpeech.js'; -import { FunctionID } from '../enums/FunctionID.js'; +import { DisplayCapabilities } from '../structs/DisplayCapabilities.js'; +import { Language } from '../enums/Language.js'; import { AudioPassThruCapabilities } from '../structs/AudioPassThruCapabilities.js'; import { VrCapabilities } from '../enums/VrCapabilities.js'; +import { ButtonCapabilities } from '../structs/ButtonCapabilities.js'; import { HMICapabilities } from '../structs/HMICapabilities.js'; +/** + * The response to registerAppInterface + */ class RegisterAppInterfaceResponse extends RpcResponse { + /** + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.RegisterAppInterface); } /** - * @param {SdlMsgVersion} The max RPC Spec version supported by this library - * @return {RegisterAppInterfaceResponse} - */ - setSdlMsgVersion (sdlMsgVersion) { - this.validateType(SdlMsgVersion, sdlMsgVersion); - - this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION, sdlMsgVersion); + * @param {SdlMsgVersion} version - See SyncMsgVersion + * @return {RegisterAppInterfaceResponse} + */ + setSdlMsgVersion (version) { + this.validateType(SdlMsgVersion, version); + this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION, version); return this; } /** - * @return {SdlMsgVersion} - */ + * @return {SdlMsgVersion} + */ getSdlMsgVersion () { return this.getObject(SdlMsgVersion, RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION); } /** - * @param {Language} language - * @return {RegisterAppInterfaceResponse} - */ + * @param {Language} language - The currently active VR+TTS language on the module. See "Language" for options. + * @return {RegisterAppInterfaceResponse} + */ setLanguage (language) { this.validateType(Language, language); - this.setParameter(RegisterAppInterfaceResponse.KEY_LANGUAGE, language); return this; } /** - * @return {Language} - */ + * @return {Language} + */ getLanguage () { return this.getObject(Language, RegisterAppInterfaceResponse.KEY_LANGUAGE); } - /** - * @param {Language} hmiDisplayLanguage - * @return {RegisterAppInterfaceResponse} - */ - setHmiDisplayLanguage (hmiDisplayLanguage) { - this.validateType(Language, hmiDisplayLanguage); - - this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE, hmiDisplayLanguage); + * @param {Language} language - The currently active display language on the module. See "Language" for options. + * @return {RegisterAppInterfaceResponse} + */ + setHmiDisplayLanguage (language) { + this.validateType(Language, language); + this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE, language); return this; } /** - * @return {Language} - */ + * @return {Language} + */ getHmiDisplayLanguage () { return this.getObject(Language, RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE); } /** - * @param {DisplayCapabilities} displayCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setDisplayCapabilities (displayCapabilities) { - this.validateType(DisplayCapabilities, displayCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES, displayCapabilities); + * @param {DisplayCapabilities} capabilities - See DisplayCapabilities. This parameter is deprecated and replaced by + * SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} + */ + setDisplayCapabilities (capabilities) { + this.validateType(DisplayCapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES, capabilities); return this; } /** - * @return {DisplayCapabilities} - */ + * @return {DisplayCapabilities} + */ getDisplayCapabilities () { return this.getObject(DisplayCapabilities, RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES); } - /** - * @param {Array} buttonCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setButtonCapabilities (buttonCapabilities) { - // TODO make this work with arrays - // this.validateType(Language, buttonCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES, buttonCapabilities); + * @param {ButtonCapabilities[]} capabilities - See ButtonCapabilities. This parameter is deprecated and replaced by + * SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} + */ + setButtonCapabilities (capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES, capabilities); return this; } /** - * @return {Array} - */ + * @return {ButtonCapabilities[]} + */ getButtonCapabilities () { return this.getObject(ButtonCapabilities, RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES); } /** - * @param {Array} softButtonCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setSoftButtonCapabilities (softButtonCapabilities) { - // TODO make this work with arrays - // this.validateType(SoftButtonCapabilities, softButtonCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES, softButtonCapabilities); + * @param {SoftButtonCapabilities[]} capabilities - If returned, the platform supports on-screen SoftButtons; see + * SoftButtonCapabilities. This parameter is deprecated and + * replaced by SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} + */ + setSoftButtonCapabilities (capabilities) { + this.validateType(SoftButtonCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES, capabilities); return this; } /** - * @return {Array} - */ + * @return {SoftButtonCapabilities[]} + */ getSoftButtonCapabilities () { return this.getObject(SoftButtonCapabilities, RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES); } /** - * @param {PresetBankCapabilities} presetBankCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setPresetBankCapabilities (presetBankCapabilities) { - this.validateType(PresetBankCapabilities, presetBankCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES, presetBankCapabilities); + * @param {PresetBankCapabilities} capabilities - If returned, the platform supports custom on-screen Presets; see + * PresetBankCapabilities. This parameter is deprecated and replaced + * by SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} + */ + setPresetBankCapabilities (capabilities) { + this.validateType(PresetBankCapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES, capabilities); return this; } /** - * @return {PresetBankCapabilities} - */ + * @return {PresetBankCapabilities} + */ getPresetBankCapabilities () { return this.getObject(PresetBankCapabilities, RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES); } /** - * @param {Array} hmiZoneCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setHmiZoneCapabilities (hmiZoneCapabilities) { - // TODO make this work for arrays - // this.validateType(HmiZoneCapabilities, hmiZoneCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES, hmiZoneCapabilities); + * @param {HmiZoneCapabilities[]} capabilities - See HmiZoneCapabilities + * @return {RegisterAppInterfaceResponse} + */ + setHmiZoneCapabilities (capabilities) { + this.validateType(HmiZoneCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES, capabilities); return this; } /** - * @return {Array} - */ + * @return {HmiZoneCapabilities[]} + */ getHmiZoneCapabilities () { return this.getObject(HmiZoneCapabilities, RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES); } /** - * @param {Array} speechCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setSpeechCapabilities (speechCapabilities) { - // TODO make this work for arrays - // this.validateType(SpeechCapabilities, speechCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES, speechCapabilities); + * @param {SpeechCapabilities[]} capabilities - See SpeechCapabilities + * @return {RegisterAppInterfaceResponse} + */ + setSpeechCapabilities (capabilities) { + this.validateType(SpeechCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES, capabilities); return this; } /** - * @return {Array} - */ + * @return {SpeechCapabilities[]} + */ getSpeechCapabilities () { return this.getObject(SpeechCapabilities, RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES); } /** - * @param {Array} speechCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setPrerecordedSpeech (speechCapabilities) { - // TODO make this work for arrays - // this.validateType(PrerecordedSpeech, speechCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH, speechCapabilities); + * @param {PrerecordedSpeech[]} speech - See PrerecordedSpeech + * @return {RegisterAppInterfaceResponse} + */ + setPrerecordedSpeech (speech) { + this.validateType(PrerecordedSpeech, speech, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH, speech); return this; } /** - * @return {Array} - */ + * @return {PrerecordedSpeech[]} + */ getPrerecordedSpeech () { return this.getObject(PrerecordedSpeech, RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH); } /** - * @param {Array} vrCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setVrCapabilities (vrCapabilities) { - // TODO make this work for arrays - // this.validateType(VrCapabilities, vrCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES, vrCapabilities); + * @param {VrCapabilities[]} capabilities - See VrCapabilities + * @return {RegisterAppInterfaceResponse} + */ + setVrCapabilities (capabilities) { + this.validateType(VrCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES, capabilities); return this; } /** - * @return {Array} - */ + * @return {VrCapabilities[]} + */ getVrCapabilities () { return this.getObject(VrCapabilities, RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES); } /** - * @param {Array} audioPassThruCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setAudioPassThruCapabilities (audioPassThruCapabilities) { - // TODO make this work for arrays - // this.validateType(AudioPassThruCapabilities, audioPassThruCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES, audioPassThruCapabilities); + * @param {AudioPassThruCapabilities[]} capabilities - See AudioPassThruCapability + * @return {RegisterAppInterfaceResponse} + */ + setAudioPassThruCapabilities (capabilities) { + this.validateType(AudioPassThruCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES, capabilities); return this; } /** - * @return {Array} - */ + * @return {AudioPassThruCapabilities[]} + */ getAudioPassThruCapabilities () { return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES); } /** - * @param {AudioPassThruCapabilities} pcmStreamCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setPcmStreamCapabilities (pcmStreamCapabilities) { - this.validateType(AudioPassThruCapabilities, pcmStreamCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES, pcmStreamCapabilities); + * @param {AudioPassThruCapabilities} capabilities - See AudioPassThruCapability + * @return {RegisterAppInterfaceResponse} + */ + setPcmStreamCapabilities (capabilities) { + this.validateType(AudioPassThruCapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES, capabilities); return this; } /** - * @return {AudioPassThruCapabilities} - */ + * @return {AudioPassThruCapabilities} + */ getPcmStreamCapabilities () { return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES); } /** - * @param {VehicleType} vehicleType - * @return {RegisterAppInterfaceResponse} - */ - setVehicleType (vehicleType) { - this.validateType(VehicleType, vehicleType); - - this.setParameter(RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE, vehicleType); + * @param {VehicleType} type - Specifies the vehicle's type. See VehicleType. + * @return {RegisterAppInterfaceResponse} + */ + setVehicleType (type) { + this.validateType(VehicleType, type); + this.setParameter(RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE, type); return this; } /** - * @return {VehicleType} - */ + * @return {VehicleType} + */ getVehicleType () { return this.getObject(VehicleType, RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE); } /** - * @param {Number} supportedDiagModes - * @return {RegisterAppInterfaceResponse} - */ - setSupportedDiagModes (supportedDiagModes) { - this.setParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE, supportedDiagModes); + * @param {Number[]} modes - Specifies the white-list of supported diagnostic modes (0x00-0xFF) capable for + * DiagnosticMessage requests. If a mode outside this list is requested, it will be + * rejected. + * @return {RegisterAppInterfaceResponse} + */ + setSupportedDiagModes (modes) { + this.setParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES, modes); return this; } /** - * @return {Number} - */ + * @return {Number[]} + */ getSupportedDiagModes () { - return this.getParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE); + return this.getParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES); } /** - * @param {HMICapabilities} hmiCapabilities - * @return {RegisterAppInterfaceResponse} - */ - setHMICapabilities (hmiCapabilities) { - this.validateType(HMICapabilities, hmiCapabilities); - - this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES, hmiCapabilities); + * @param {HMICapabilities} capabilities - Specifies the HMI's capabilities. See HMICapabilities. + * @return {RegisterAppInterfaceResponse} + */ + setHmiCapabilities (capabilities) { + this.validateType(HMICapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES, capabilities); return this; } /** - * @return {HMICapabilities} - */ - getHMICapabilities () { + * @return {HMICapabilities} + */ + getHmiCapabilities () { return this.getObject(HMICapabilities, RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES); } /** - * @param {String} sdlVersion - * @return {RegisterAppInterfaceResponse} - */ - setSdlVersion (sdlVersion) { - this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION, sdlVersion); + * @param {String} version - The SmartDeviceLink version. + * @return {RegisterAppInterfaceResponse} + */ + setSdlVersion (version) { + this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION, version); return this; } /** - * @return {String} - */ + * @return {String} + */ getSdlVersion () { return this.getParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION); } /** - * @param {String} systemSoftwareVersion - * @return {RegisterAppInterfaceResponse} - */ - setSystemSoftwareVersion (systemSoftwareVersion) { - this.setParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION, systemSoftwareVersion); + * @param {String} version - The software version of the system that implements the SmartDeviceLink core. + * @return {RegisterAppInterfaceResponse} + */ + setSystemSoftwareVersion (version) { + this.setParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION, version); return this; } /** - * @return {String} - */ + * @return {String} + */ getSystemSoftwareVersion () { return this.getParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION); } /** - * @param {Boolean} iconResumed - * @return {RegisterAppInterfaceResponse} - */ - setIconResumed (iconResumed) { - this.setParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED, iconResumed); + * @param {Boolean} resumed - Existence of apps icon at system. If true, apps icon was resumed at system. If false, + * apps icon is not resumed at system + * @return {RegisterAppInterfaceResponse} + */ + setIconResumed (resumed) { + this.setParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED, resumed); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getIconResumed () { return this.getParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED); } @@ -410,10 +402,10 @@ RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES = 'vrCapabilities'; RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES = 'audioPassThruCapabilities'; RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES = 'pcmStreamCapabilities'; RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE = 'vehicleType'; -RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE = 'supportedDiagModes'; +RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES = 'supportedDiagModes'; RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES = 'hmiCapabilities'; RegisterAppInterfaceResponse.KEY_SDL_VERSION = 'sdlVersion'; RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION = 'systemSoftwareVersion'; RegisterAppInterfaceResponse.KEY_ICON_RESUMED = 'iconResumed'; -export { RegisterAppInterfaceResponse }; +export { RegisterAppInterfaceResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ReleaseInteriorVehicleDataModule.js b/lib/js/src/rpc/messages/ReleaseInteriorVehicleDataModule.js new file mode 100644 index 00000000..98daee7c --- /dev/null +++ b/lib/js/src/rpc/messages/ReleaseInteriorVehicleDataModule.js @@ -0,0 +1,84 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { ModuleType } from '../enums/ModuleType.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +class ReleaseInteriorVehicleDataModule extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ReleaseInteriorVehicleDataModule); + } + + /** + * @param {ModuleType} type + * @return {ReleaseInteriorVehicleDataModule} + */ + setModuleType (type) { + this.validateType(ModuleType, type); + this.setParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE, type); + return this; + } + + /** + * @return {ModuleType} + */ + getModuleType () { + return this.getObject(ModuleType, ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE); + } + + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {ReleaseInteriorVehicleDataModule} + */ + setModuleId (id) { + this.setParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_ID, id); + return this; + } + + /** + * @return {String} + */ + getModuleId () { + return this.getParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_ID); + } +} + +ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE = 'moduleType'; +ReleaseInteriorVehicleDataModule.KEY_MODULE_ID = 'moduleId'; + +export { ReleaseInteriorVehicleDataModule }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ReleaseInteriorVehicleDataModuleResponse.js b/lib/js/src/rpc/messages/ReleaseInteriorVehicleDataModuleResponse.js new file mode 100644 index 00000000..b01a77b6 --- /dev/null +++ b/lib/js/src/rpc/messages/ReleaseInteriorVehicleDataModuleResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ReleaseInteriorVehicleDataModuleResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ReleaseInteriorVehicleDataModule); + } +} + + +export { ReleaseInteriorVehicleDataModuleResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ResetGlobalProperties.js b/lib/js/src/rpc/messages/ResetGlobalProperties.js new file mode 100644 index 00000000..4e38a2e8 --- /dev/null +++ b/lib/js/src/rpc/messages/ResetGlobalProperties.js @@ -0,0 +1,72 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { GlobalProperty } from '../enums/GlobalProperty.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Allows resetting global properties. + */ +class ResetGlobalProperties extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ResetGlobalProperties); + } + + /** + * @param {GlobalProperty[]} properties - Contains the names of all global properties (like timeoutPrompt) that + * should be unset. Resetting means, that they have the same value as at + * start up (default) + * @return {ResetGlobalProperties} + */ + setProperties (properties) { + this.validateType(GlobalProperty, properties, true); + this.setParameter(ResetGlobalProperties.KEY_PROPERTIES, properties); + return this; + } + + /** + * @return {GlobalProperty[]} + */ + getProperties () { + return this.getObject(GlobalProperty, ResetGlobalProperties.KEY_PROPERTIES); + } +} + +ResetGlobalProperties.KEY_PROPERTIES = 'properties'; + +export { ResetGlobalProperties }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ResetGlobalPropertiesResponse.js b/lib/js/src/rpc/messages/ResetGlobalPropertiesResponse.js new file mode 100644 index 00000000..969b1abb --- /dev/null +++ b/lib/js/src/rpc/messages/ResetGlobalPropertiesResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ResetGlobalPropertiesResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ResetGlobalProperties); + } +} + + +export { ResetGlobalPropertiesResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ScrollableMessage.js b/lib/js/src/rpc/messages/ScrollableMessage.js new file mode 100644 index 00000000..185306bf --- /dev/null +++ b/lib/js/src/rpc/messages/ScrollableMessage.js @@ -0,0 +1,125 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { SoftButton } from '../structs/SoftButton.js'; + +/** + * Creates a full screen overlay containing a large block of formatted text that can be scrolled with up to 8 + * SoftButtons defined + */ +class ScrollableMessage extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ScrollableMessage); + } + + /** + * @param {String} body - Body of text that can include newlines and tabs. + * @return {ScrollableMessage} + */ + setScrollableMessageBody (body) { + this.setParameter(ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY, body); + return this; + } + + /** + * @return {String} + */ + getScrollableMessageBody () { + return this.getParameter(ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY); + } + + /** + * @param {Number} timeout - App defined timeout. Indicates how long of a timeout from the last action (i.e. + * scrolling message resets timeout). + * @return {ScrollableMessage} + */ + setTimeout (timeout) { + this.setParameter(ScrollableMessage.KEY_TIMEOUT, timeout); + return this; + } + + /** + * @return {Number} + */ + getTimeout () { + return this.getParameter(ScrollableMessage.KEY_TIMEOUT); + } + + /** + * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, only the system + * defined "Close" SoftButton will be displayed. + * @return {ScrollableMessage} + */ + setSoftButtons (buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(ScrollableMessage.KEY_SOFT_BUTTONS, buttons); + return this; + } + + /** + * @return {SoftButton[]} + */ + getSoftButtons () { + return this.getObject(SoftButton, ScrollableMessage.KEY_SOFT_BUTTONS); + } + + /** + * @param {Number} id - An ID for this specific ScrollableMessage to allow cancellation through the + * `CancelInteraction` RPC. + * @return {ScrollableMessage} + */ + setCancelID (id) { + this.setParameter(ScrollableMessage.KEY_CANCEL_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCancelID () { + return this.getParameter(ScrollableMessage.KEY_CANCEL_ID); + } +} + +ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY = 'scrollableMessageBody'; +ScrollableMessage.KEY_TIMEOUT = 'timeout'; +ScrollableMessage.KEY_SOFT_BUTTONS = 'softButtons'; +ScrollableMessage.KEY_CANCEL_ID = 'cancelID'; + +export { ScrollableMessage }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ScrollableMessageResponse.js b/lib/js/src/rpc/messages/ScrollableMessageResponse.js new file mode 100644 index 00000000..375f76b8 --- /dev/null +++ b/lib/js/src/rpc/messages/ScrollableMessageResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ScrollableMessageResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ScrollableMessage); + } +} + + +export { ScrollableMessageResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SendHapticData.js b/lib/js/src/rpc/messages/SendHapticData.js new file mode 100644 index 00000000..f045bfc1 --- /dev/null +++ b/lib/js/src/rpc/messages/SendHapticData.js @@ -0,0 +1,75 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { HapticRect } from '../structs/HapticRect.js'; + +/** + * Send the spatial data gathered from SDLCarWindow or VirtualDisplayEncoder to the HMI. This data will be utilized by + * the HMI to determine how and when haptic events should occur + */ +class SendHapticData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SendHapticData); + } + + /** + * @param {HapticRect[]} data - Array of spatial data structures that represent the locations of all user controls + * present on the HMI. This data should be updated if/when the application presents a + * new screen. When a request is sent, if successful, it will replace all spatial data + * previously sent through RPC. If an empty array is sent, the existing spatial data + * will be cleared + * @return {SendHapticData} + */ + setHapticRectData (data) { + this.validateType(HapticRect, data, true); + this.setParameter(SendHapticData.KEY_HAPTIC_RECT_DATA, data); + return this; + } + + /** + * @return {HapticRect[]} + */ + getHapticRectData () { + return this.getObject(HapticRect, SendHapticData.KEY_HAPTIC_RECT_DATA); + } +} + +SendHapticData.KEY_HAPTIC_RECT_DATA = 'hapticRectData'; + +export { SendHapticData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SendHapticDataResponse.js b/lib/js/src/rpc/messages/SendHapticDataResponse.js new file mode 100644 index 00000000..39c979c7 --- /dev/null +++ b/lib/js/src/rpc/messages/SendHapticDataResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SendHapticDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SendHapticData); + } +} + + +export { SendHapticDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SendLocation.js b/lib/js/src/rpc/messages/SendLocation.js new file mode 100644 index 00000000..f949f9cb --- /dev/null +++ b/lib/js/src/rpc/messages/SendLocation.js @@ -0,0 +1,226 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { DeliveryMode } from '../enums/DeliveryMode.js'; +import { DateTime } from '../structs/DateTime.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { OASISAddress } from '../structs/OASISAddress.js'; +import { Image } from '../structs/Image.js'; + +class SendLocation extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SendLocation); + } + + /** + * @param {Number} degrees + * @return {SendLocation} + */ + setLongitudeDegrees (degrees) { + this.setParameter(SendLocation.KEY_LONGITUDE_DEGREES, degrees); + return this; + } + + /** + * @return {Number} + */ + getLongitudeDegrees () { + return this.getParameter(SendLocation.KEY_LONGITUDE_DEGREES); + } + + /** + * @param {Number} degrees + * @return {SendLocation} + */ + setLatitudeDegrees (degrees) { + this.setParameter(SendLocation.KEY_LATITUDE_DEGREES, degrees); + return this; + } + + /** + * @return {Number} + */ + getLatitudeDegrees () { + return this.getParameter(SendLocation.KEY_LATITUDE_DEGREES); + } + + /** + * @param {String} name - Name / title of intended location + * @return {SendLocation} + */ + setLocationName (name) { + this.setParameter(SendLocation.KEY_LOCATION_NAME, name); + return this; + } + + /** + * @return {String} + */ + getLocationName () { + return this.getParameter(SendLocation.KEY_LOCATION_NAME); + } + + /** + * @param {String} description - Description intended location / establishment (if applicable) + * @return {SendLocation} + */ + setLocationDescription (description) { + this.setParameter(SendLocation.KEY_LOCATION_DESCRIPTION, description); + return this; + } + + /** + * @return {String} + */ + getLocationDescription () { + return this.getParameter(SendLocation.KEY_LOCATION_DESCRIPTION); + } + + /** + * @param {String[]} lines - Location address (if applicable) + * @return {SendLocation} + */ + setAddressLines (lines) { + this.setParameter(SendLocation.KEY_ADDRESS_LINES, lines); + return this; + } + + /** + * @return {String[]} + */ + getAddressLines () { + return this.getParameter(SendLocation.KEY_ADDRESS_LINES); + } + + /** + * @param {String} number - Phone number of intended location / establishment (if applicable) + * @return {SendLocation} + */ + setPhoneNumber (number) { + this.setParameter(SendLocation.KEY_PHONE_NUMBER, number); + return this; + } + + /** + * @return {String} + */ + getPhoneNumber () { + return this.getParameter(SendLocation.KEY_PHONE_NUMBER); + } + + /** + * @param {Image} image - Image / icon of intended location (if applicable and supported) + * @return {SendLocation} + */ + setLocationImage (image) { + this.validateType(Image, image); + this.setParameter(SendLocation.KEY_LOCATION_IMAGE, image); + return this; + } + + /** + * @return {Image} + */ + getLocationImage () { + return this.getObject(Image, SendLocation.KEY_LOCATION_IMAGE); + } + + /** + * @param {DateTime} stamp - timestamp in ISO 8601 format + * @return {SendLocation} + */ + setTimeStamp (stamp) { + this.validateType(DateTime, stamp); + this.setParameter(SendLocation.KEY_TIME_STAMP, stamp); + return this; + } + + /** + * @return {DateTime} + */ + getTimeStamp () { + return this.getObject(DateTime, SendLocation.KEY_TIME_STAMP); + } + + /** + * @param {OASISAddress} address - Address to be used for setting destination + * @return {SendLocation} + */ + setAddress (address) { + this.validateType(OASISAddress, address); + this.setParameter(SendLocation.KEY_ADDRESS, address); + return this; + } + + /** + * @return {OASISAddress} + */ + getAddress () { + return this.getObject(OASISAddress, SendLocation.KEY_ADDRESS); + } + + /** + * @param {DeliveryMode} mode - Defines the mode of prompt for user + * @return {SendLocation} + */ + setDeliveryMode (mode) { + this.validateType(DeliveryMode, mode); + this.setParameter(SendLocation.KEY_DELIVERY_MODE, mode); + return this; + } + + /** + * @return {DeliveryMode} + */ + getDeliveryMode () { + return this.getObject(DeliveryMode, SendLocation.KEY_DELIVERY_MODE); + } +} + +SendLocation.KEY_LONGITUDE_DEGREES = 'longitudeDegrees'; +SendLocation.KEY_LATITUDE_DEGREES = 'latitudeDegrees'; +SendLocation.KEY_LOCATION_NAME = 'locationName'; +SendLocation.KEY_LOCATION_DESCRIPTION = 'locationDescription'; +SendLocation.KEY_ADDRESS_LINES = 'addressLines'; +SendLocation.KEY_PHONE_NUMBER = 'phoneNumber'; +SendLocation.KEY_LOCATION_IMAGE = 'locationImage'; +SendLocation.KEY_TIME_STAMP = 'timeStamp'; +SendLocation.KEY_ADDRESS = 'address'; +SendLocation.KEY_DELIVERY_MODE = 'deliveryMode'; + +export { SendLocation }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SendLocationResponse.js b/lib/js/src/rpc/messages/SendLocationResponse.js new file mode 100644 index 00000000..17895eb8 --- /dev/null +++ b/lib/js/src/rpc/messages/SendLocationResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SendLocationResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SendLocation); + } +} + + +export { SendLocationResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetAppIcon.js b/lib/js/src/rpc/messages/SetAppIcon.js index 0d9b13ce..fc73ae6c 100644 --- a/lib/js/src/rpc/messages/SetAppIcon.js +++ b/lib/js/src/rpc/messages/SetAppIcon.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,27 +34,31 @@ import { RpcRequest } from '../RpcRequest.js'; import { FunctionID } from '../enums/FunctionID.js'; +/** + * Used to set existing local file on the module as the app's icon Not supported on first generation SDL enabled + * vehicles. + */ class SetAppIcon extends RpcRequest { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.SetAppIcon); } /** - * @param {String} fileName - * @return {SetAppIcon} - */ - setFileName (fileName) { - this.setParameter(SetAppIcon.KEY_FILE_NAME, fileName); + * @param {String} name - File reference name. + * @return {SetAppIcon} + */ + setFileName (name) { + this.setParameter(SetAppIcon.KEY_FILE_NAME, name); return this; } /** - * @return {String} - */ + * @return {String} + */ getFileName () { return this.getParameter(SetAppIcon.KEY_FILE_NAME); } @@ -61,5 +66,4 @@ class SetAppIcon extends RpcRequest { SetAppIcon.KEY_FILE_NAME = 'syncFileName'; - -export { SetAppIcon }; +export { SetAppIcon }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetAppIconResponse.js b/lib/js/src/rpc/messages/SetAppIconResponse.js index 5051fc83..b1f2ffae 100644 --- a/lib/js/src/rpc/messages/SetAppIconResponse.js +++ b/lib/js/src/rpc/messages/SetAppIconResponse.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,17 +31,22 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcResponse } from '../RpcResponse.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; +/** + * Response is sent, when the file data was copied (success case). Or when an error occurred. Not supported on First + * generation SDL enabled vehicles. + */ class SetAppIconResponse extends RpcResponse { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.SetAppIcon); } } -export { SetAppIconResponse }; + +export { SetAppIconResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetCloudAppProperties.js b/lib/js/src/rpc/messages/SetCloudAppProperties.js new file mode 100644 index 00000000..cae17605 --- /dev/null +++ b/lib/js/src/rpc/messages/SetCloudAppProperties.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { CloudAppProperties } from '../structs/CloudAppProperties.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * RPC used to enable/disable a cloud application and set its cloud-related policy properties + */ +class SetCloudAppProperties extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetCloudAppProperties); + } + + /** + * @param {CloudAppProperties} properties - The new cloud application properties + * @return {SetCloudAppProperties} + */ + setProperties (properties) { + this.validateType(CloudAppProperties, properties); + this.setParameter(SetCloudAppProperties.KEY_PROPERTIES, properties); + return this; + } + + /** + * @return {CloudAppProperties} + */ + getProperties () { + return this.getObject(CloudAppProperties, SetCloudAppProperties.KEY_PROPERTIES); + } +} + +SetCloudAppProperties.KEY_PROPERTIES = 'properties'; + +export { SetCloudAppProperties }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetCloudAppPropertiesResponse.js b/lib/js/src/rpc/messages/SetCloudAppPropertiesResponse.js new file mode 100644 index 00000000..4325e97c --- /dev/null +++ b/lib/js/src/rpc/messages/SetCloudAppPropertiesResponse.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * The response to SetCloudAppProperties + */ +class SetCloudAppPropertiesResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetCloudAppProperties); + } +} + + +export { SetCloudAppPropertiesResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetDisplayLayout.js b/lib/js/src/rpc/messages/SetDisplayLayout.js new file mode 100644 index 00000000..47a89e17 --- /dev/null +++ b/lib/js/src/rpc/messages/SetDisplayLayout.js @@ -0,0 +1,114 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { TemplateColorScheme } from '../structs/TemplateColorScheme.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * This RPC is deprecated. Use Show RPC to change layout. + * @deprecated + */ +class SetDisplayLayout extends RpcRequest { + /** + * @deprecated + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetDisplayLayout); + } + + /** + * @deprecated + * @param {String} layout - Predefined or dynamically created screen layout. Currently only predefined screen + * layouts are defined. + * @return {SetDisplayLayout} + */ + setDisplayLayout (layout) { + this.setParameter(SetDisplayLayout.KEY_DISPLAY_LAYOUT, layout); + return this; + } + + /** + * @deprecated + * @return {String} + */ + getDisplayLayout () { + return this.getParameter(SetDisplayLayout.KEY_DISPLAY_LAYOUT); + } + + /** + * @deprecated + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {SetDisplayLayout} + */ + setDayColorScheme (scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(SetDisplayLayout.KEY_DAY_COLOR_SCHEME, scheme); + return this; + } + + /** + * @deprecated + * @return {TemplateColorScheme} + */ + getDayColorScheme () { + return this.getObject(TemplateColorScheme, SetDisplayLayout.KEY_DAY_COLOR_SCHEME); + } + + /** + * @deprecated + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {SetDisplayLayout} + */ + setNightColorScheme (scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME, scheme); + return this; + } + + /** + * @deprecated + * @return {TemplateColorScheme} + */ + getNightColorScheme () { + return this.getObject(TemplateColorScheme, SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME); + } +} + +SetDisplayLayout.KEY_DISPLAY_LAYOUT = 'displayLayout'; +SetDisplayLayout.KEY_DAY_COLOR_SCHEME = 'dayColorScheme'; +SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme'; + +export { SetDisplayLayout }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetDisplayLayoutResponse.js b/lib/js/src/rpc/messages/SetDisplayLayoutResponse.js new file mode 100644 index 00000000..77851fad --- /dev/null +++ b/lib/js/src/rpc/messages/SetDisplayLayoutResponse.js @@ -0,0 +1,139 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcResponse } from '../RpcResponse.js'; +import { SoftButtonCapabilities } from '../structs/SoftButtonCapabilities.js'; +import { PresetBankCapabilities } from '../structs/PresetBankCapabilities.js'; +import { DisplayCapabilities } from '../structs/DisplayCapabilities.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { ButtonCapabilities } from '../structs/ButtonCapabilities.js'; + +/** + * This RPC is deprecated. Use Show RPC to change layout. + * @deprecated + */ +class SetDisplayLayoutResponse extends RpcResponse { + /** + * @deprecated + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetDisplayLayout); + } + + /** + * @deprecated + * @param {DisplayCapabilities} capabilities - See DisplayCapabilities + * @return {SetDisplayLayoutResponse} + */ + setDisplayCapabilities (capabilities) { + this.validateType(DisplayCapabilities, capabilities); + this.setParameter(SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES, capabilities); + return this; + } + + /** + * @deprecated + * @return {DisplayCapabilities} + */ + getDisplayCapabilities () { + return this.getObject(DisplayCapabilities, SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES); + } + + /** + * @deprecated + * @param {ButtonCapabilities[]} capabilities - See ButtonCapabilities + * @return {SetDisplayLayoutResponse} + */ + setButtonCapabilities (capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES, capabilities); + return this; + } + + /** + * @deprecated + * @return {ButtonCapabilities[]} + */ + getButtonCapabilities () { + return this.getObject(ButtonCapabilities, SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES); + } + + /** + * @deprecated + * @param {SoftButtonCapabilities[]} capabilities - If returned, the platform supports on-screen SoftButtons; see + * SoftButtonCapabilities. + * @return {SetDisplayLayoutResponse} + */ + setSoftButtonCapabilities (capabilities) { + this.validateType(SoftButtonCapabilities, capabilities, true); + this.setParameter(SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES, capabilities); + return this; + } + + /** + * @deprecated + * @return {SoftButtonCapabilities[]} + */ + getSoftButtonCapabilities () { + return this.getObject(SoftButtonCapabilities, SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES); + } + + /** + * @deprecated + * @param {PresetBankCapabilities} capabilities - If returned, the platform supports custom on-screen Presets; see + * PresetBankCapabilities. + * @return {SetDisplayLayoutResponse} + */ + setPresetBankCapabilities (capabilities) { + this.validateType(PresetBankCapabilities, capabilities); + this.setParameter(SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES, capabilities); + return this; + } + + /** + * @deprecated + * @return {PresetBankCapabilities} + */ + getPresetBankCapabilities () { + return this.getObject(PresetBankCapabilities, SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES); + } +} + +SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities'; +SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; +SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities'; +SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES = 'presetBankCapabilities'; + +export { SetDisplayLayoutResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetGlobalProperties.js b/lib/js/src/rpc/messages/SetGlobalProperties.js new file mode 100644 index 00000000..e1f13a28 --- /dev/null +++ b/lib/js/src/rpc/messages/SetGlobalProperties.js @@ -0,0 +1,226 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { VrHelpItem } from '../structs/VrHelpItem.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { SeatLocation } from '../structs/SeatLocation.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { MenuLayout } from '../enums/MenuLayout.js'; +import { KeyboardProperties } from '../structs/KeyboardProperties.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { Image } from '../structs/Image.js'; + +/** + * Allows setting global properties. + */ +class SetGlobalProperties extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetGlobalProperties); + } + + /** + * @param {SeatLocation} location - Location of the user's seat. Default is driver's seat location if it is not set + * yet. + * @return {SetGlobalProperties} + */ + setUserLocation (location) { + this.validateType(SeatLocation, location); + this.setParameter(SetGlobalProperties.KEY_USER_LOCATION, location); + return this; + } + + /** + * @return {SeatLocation} + */ + getUserLocation () { + return this.getObject(SeatLocation, SetGlobalProperties.KEY_USER_LOCATION); + } + + /** + * @param {TTSChunk[]} prompt - The help prompt. An array of text chunks of type TTSChunk. See TTSChunk. The array + * must have at least one item. + * @return {SetGlobalProperties} + */ + setHelpPrompt (prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(SetGlobalProperties.KEY_HELP_PROMPT, prompt); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getHelpPrompt () { + return this.getObject(TTSChunk, SetGlobalProperties.KEY_HELP_PROMPT); + } + + /** + * @param {TTSChunk[]} prompt - Help text for a wait timeout. An array of text chunks of type TTSChunk. See + * TTSChunk. The array must have at least one item. + * @return {SetGlobalProperties} + */ + setTimeoutPrompt (prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(SetGlobalProperties.KEY_TIMEOUT_PROMPT, prompt); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getTimeoutPrompt () { + return this.getObject(TTSChunk, SetGlobalProperties.KEY_TIMEOUT_PROMPT); + } + + /** + * @param {String} title - VR Help Title text. If omitted on supported displays, the default module help title shall + * be used. If omitted and one or more vrHelp items are provided, the request will be + * rejected. + * @return {SetGlobalProperties} + */ + setVrHelpTitle (title) { + this.setParameter(SetGlobalProperties.KEY_VR_HELP_TITLE, title); + return this; + } + + /** + * @return {String} + */ + getVrHelpTitle () { + return this.getParameter(SetGlobalProperties.KEY_VR_HELP_TITLE); + } + + /** + * @param {VrHelpItem[]} help - VR Help Items. If omitted on supported displays, the default SmartDeviceLink VR help + * / What Can I Say? screen shall be used. If the list of VR Help Items contains + * nonsequential positions (e.g. [1,2,4]), the RPC shall be rejected. If omitted and a + * vrHelpTitle is provided, the request will be rejected. + * @return {SetGlobalProperties} + */ + setVrHelp (help) { + this.validateType(VrHelpItem, help, true); + this.setParameter(SetGlobalProperties.KEY_VR_HELP, help); + return this; + } + + /** + * @return {VrHelpItem[]} + */ + getVrHelp () { + return this.getObject(VrHelpItem, SetGlobalProperties.KEY_VR_HELP); + } + + /** + * @param {String} title - Optional text to label an app menu button (for certain touchscreen platforms). + * @return {SetGlobalProperties} + */ + setMenuTitle (title) { + this.setParameter(SetGlobalProperties.KEY_MENU_TITLE, title); + return this; + } + + /** + * @return {String} + */ + getMenuTitle () { + return this.getParameter(SetGlobalProperties.KEY_MENU_TITLE); + } + + /** + * @param {Image} icon - Optional icon to draw on an app menu button (for certain touchscreen platforms). + * @return {SetGlobalProperties} + */ + setMenuIcon (icon) { + this.validateType(Image, icon); + this.setParameter(SetGlobalProperties.KEY_MENU_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getMenuIcon () { + return this.getObject(Image, SetGlobalProperties.KEY_MENU_ICON); + } + + /** + * @param {KeyboardProperties} properties - On-screen keyboard configuration (if available). + * @return {SetGlobalProperties} + */ + setKeyboardProperties (properties) { + this.validateType(KeyboardProperties, properties); + this.setParameter(SetGlobalProperties.KEY_KEYBOARD_PROPERTIES, properties); + return this; + } + + /** + * @return {KeyboardProperties} + */ + getKeyboardProperties () { + return this.getObject(KeyboardProperties, SetGlobalProperties.KEY_KEYBOARD_PROPERTIES); + } + + /** + * @param {MenuLayout} layout - Sets the layout of the main menu screen. If this is sent while a menu is already on- + * screen, the head unit will change the display to the new layout type. + * @return {SetGlobalProperties} + */ + setMenuLayout (layout) { + this.validateType(MenuLayout, layout); + this.setParameter(SetGlobalProperties.KEY_MENU_LAYOUT, layout); + return this; + } + + /** + * @return {MenuLayout} + */ + getMenuLayout () { + return this.getObject(MenuLayout, SetGlobalProperties.KEY_MENU_LAYOUT); + } +} + +SetGlobalProperties.KEY_USER_LOCATION = 'userLocation'; +SetGlobalProperties.KEY_HELP_PROMPT = 'helpPrompt'; +SetGlobalProperties.KEY_TIMEOUT_PROMPT = 'timeoutPrompt'; +SetGlobalProperties.KEY_VR_HELP_TITLE = 'vrHelpTitle'; +SetGlobalProperties.KEY_VR_HELP = 'vrHelp'; +SetGlobalProperties.KEY_MENU_TITLE = 'menuTitle'; +SetGlobalProperties.KEY_MENU_ICON = 'menuIcon'; +SetGlobalProperties.KEY_KEYBOARD_PROPERTIES = 'keyboardProperties'; +SetGlobalProperties.KEY_MENU_LAYOUT = 'menuLayout'; + +export { SetGlobalProperties }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetGlobalPropertiesResponse.js b/lib/js/src/rpc/messages/SetGlobalPropertiesResponse.js new file mode 100644 index 00000000..866addb5 --- /dev/null +++ b/lib/js/src/rpc/messages/SetGlobalPropertiesResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SetGlobalPropertiesResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetGlobalProperties); + } +} + + +export { SetGlobalPropertiesResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetInteriorVehicleData.js b/lib/js/src/rpc/messages/SetInteriorVehicleData.js new file mode 100644 index 00000000..9a9ccb14 --- /dev/null +++ b/lib/js/src/rpc/messages/SetInteriorVehicleData.js @@ -0,0 +1,67 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { ModuleData } from '../structs/ModuleData.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +class SetInteriorVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetInteriorVehicleData); + } + + /** + * @param {ModuleData} data - The module data to set for the requested RC module. + * @return {SetInteriorVehicleData} + */ + setModuleData (data) { + this.validateType(ModuleData, data); + this.setParameter(SetInteriorVehicleData.KEY_MODULE_DATA, data); + return this; + } + + /** + * @return {ModuleData} + */ + getModuleData () { + return this.getObject(ModuleData, SetInteriorVehicleData.KEY_MODULE_DATA); + } +} + +SetInteriorVehicleData.KEY_MODULE_DATA = 'moduleData'; + +export { SetInteriorVehicleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetInteriorVehicleDataResponse.js b/lib/js/src/rpc/messages/SetInteriorVehicleDataResponse.js new file mode 100644 index 00000000..617534cb --- /dev/null +++ b/lib/js/src/rpc/messages/SetInteriorVehicleDataResponse.js @@ -0,0 +1,72 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { ModuleData } from '../structs/ModuleData.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * Used to set the values of one remote control module + */ +class SetInteriorVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetInteriorVehicleData); + } + + /** + * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which + * data object exists in this struct. For example, if the moduleType is CLIMATE then a + * "climateControlData" should exist + * @return {SetInteriorVehicleDataResponse} + */ + setModuleData (data) { + this.validateType(ModuleData, data); + this.setParameter(SetInteriorVehicleDataResponse.KEY_MODULE_DATA, data); + return this; + } + + /** + * @return {ModuleData} + */ + getModuleData () { + return this.getObject(ModuleData, SetInteriorVehicleDataResponse.KEY_MODULE_DATA); + } +} + +SetInteriorVehicleDataResponse.KEY_MODULE_DATA = 'moduleData'; + +export { SetInteriorVehicleDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetMediaClockTimer.js b/lib/js/src/rpc/messages/SetMediaClockTimer.js new file mode 100644 index 00000000..6b5993a7 --- /dev/null +++ b/lib/js/src/rpc/messages/SetMediaClockTimer.js @@ -0,0 +1,135 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { StartTime } from '../structs/StartTime.js'; +import { UpdateMode } from '../enums/UpdateMode.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { AudioStreamingIndicator } from '../enums/AudioStreamingIndicator.js'; +import { RpcRequest } from '../RpcRequest.js'; + +/** + * Sets the initial media clock value and automatic update method. + */ +class SetMediaClockTimer extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetMediaClockTimer); + } + + /** + * @param {StartTime} time - See StartTime. startTime must be provided for "COUNTUP" and "COUNTDOWN". startTime will + * be ignored for "RESUME", and "CLEAR" startTime can be sent for "PAUSE", in which case + * it will update the paused startTime + * @return {SetMediaClockTimer} + */ + setStartTime (time) { + this.validateType(StartTime, time); + this.setParameter(SetMediaClockTimer.KEY_START_TIME, time); + return this; + } + + /** + * @return {StartTime} + */ + getStartTime () { + return this.getObject(StartTime, SetMediaClockTimer.KEY_START_TIME); + } + + /** + * @param {StartTime} time - See StartTime. endTime can be provided for "COUNTUP" and "COUNTDOWN"; to be used to + * calculate any visual progress bar (if not provided, this feature is ignored) If endTime + * is greater then startTime for COUNTDOWN or less than startTime for COUNTUP, then the + * request will return an INVALID_DATA. endTime will be ignored for "RESUME", and "CLEAR" + * endTime can be sent for "PAUSE", in which case it will update the paused endTime + * @return {SetMediaClockTimer} + */ + setEndTime (time) { + this.validateType(StartTime, time); + this.setParameter(SetMediaClockTimer.KEY_END_TIME, time); + return this; + } + + /** + * @return {StartTime} + */ + getEndTime () { + return this.getObject(StartTime, SetMediaClockTimer.KEY_END_TIME); + } + + /** + * @param {UpdateMode} mode - Enumeration to control the media clock. In case of pause, resume, or clear, the start + * time value is ignored and shall be left out. For resume, the time continues with the + * same value as it was when paused. + * @return {SetMediaClockTimer} + */ + setUpdateMode (mode) { + this.validateType(UpdateMode, mode); + this.setParameter(SetMediaClockTimer.KEY_UPDATE_MODE, mode); + return this; + } + + /** + * @return {UpdateMode} + */ + getUpdateMode () { + return this.getObject(UpdateMode, SetMediaClockTimer.KEY_UPDATE_MODE); + } + + /** + * @param {AudioStreamingIndicator} indicator - Enumeration for the indicator icon on a play/pause button. see + * AudioStreamingIndicator. + * @return {SetMediaClockTimer} + */ + setAudioStreamingIndicator (indicator) { + this.validateType(AudioStreamingIndicator, indicator); + this.setParameter(SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR, indicator); + return this; + } + + /** + * @return {AudioStreamingIndicator} + */ + getAudioStreamingIndicator () { + return this.getObject(AudioStreamingIndicator, SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR); + } +} + +SetMediaClockTimer.KEY_START_TIME = 'startTime'; +SetMediaClockTimer.KEY_END_TIME = 'endTime'; +SetMediaClockTimer.KEY_UPDATE_MODE = 'updateMode'; +SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR = 'audioStreamingIndicator'; + +export { SetMediaClockTimer }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SetMediaClockTimerResponse.js b/lib/js/src/rpc/messages/SetMediaClockTimerResponse.js new file mode 100644 index 00000000..5b633cfa --- /dev/null +++ b/lib/js/src/rpc/messages/SetMediaClockTimerResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SetMediaClockTimerResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SetMediaClockTimer); + } +} + + +export { SetMediaClockTimerResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/Show.js b/lib/js/src/rpc/messages/Show.js index 91c6e662..b6133f00 100644 --- a/lib/js/src/rpc/messages/Show.js +++ b/lib/js/src/rpc/messages/Show.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,274 +31,311 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcRequest } from '../RpcRequest.js'; +import { TextAlignment } from '../enums/TextAlignment.js'; +import { FunctionID } from '../enums/FunctionID.js'; import { SoftButton } from '../structs/SoftButton.js'; -import { Image } from '../structs/Image.js'; +import { TemplateConfiguration } from '../structs/TemplateConfiguration.js'; import { MetadataTags } from '../structs/MetadataTags.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { Image } from '../structs/Image.js'; -import { FunctionID } from '../enums/FunctionID.js'; -import { TextAlignment } from '../enums/TextAlignment.js'; - +/** + * Updates the persistent display. Supported fields depend on display capabilities. + */ class Show extends RpcRequest { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.Show); } - /** - * @param {String} mainField1 - * @return {Show} - */ - setMainField1 (mainField1) { - this.setParameter(Show.KEY_MAIN_FIELD_1, mainField1); + * @param {String} field1 - The text that should be displayed in a single or upper display line. If this text is not + * set, the text of mainField1 stays unchanged. If this text is empty "", the field will be + * cleared. + * @return {Show} + */ + setMainField1 (field1) { + this.setParameter(Show.KEY_MAIN_FIELD_1, field1); return this; } /** - * @return {String} - */ + * @return {String} + */ getMainField1 () { return this.getParameter(Show.KEY_MAIN_FIELD_1); } /** - * @param {String} mainField2 - * @return {Show} - */ - setMainField2 (mainField2) { - this.setParameter(Show.KEY_MAIN_FIELD_2, mainField2); + * @param {String} field2 - The text that should be displayed on the second display line. If this text is not set, + * the text of mainField2 stays unchanged. If this text is empty "", the field will be + * cleared. + * @return {Show} + */ + setMainField2 (field2) { + this.setParameter(Show.KEY_MAIN_FIELD_2, field2); return this; } /** - * @return {String} - */ + * @return {String} + */ getMainField2 () { return this.getParameter(Show.KEY_MAIN_FIELD_2); } /** - * @param {String} mainField3 - * @return {Show} - */ - setMainField3 (mainField3) { - this.setParameter(Show.KEY_MAIN_FIELD_3, mainField3); + * @param {String} field3 - The text that should be displayed on the second "page" first display line. If this text + * is not set, the text of mainField3 stays unchanged. If this text is empty "", the field + * will be cleared. + * @return {Show} + */ + setMainField3 (field3) { + this.setParameter(Show.KEY_MAIN_FIELD_3, field3); return this; } /** - * @return {String} - */ + * @return {String} + */ getMainField3 () { return this.getParameter(Show.KEY_MAIN_FIELD_3); } /** - * @param {String} mainField4 - * @return {Show} - */ - setMainField4 (mainField4) { - this.setParameter(Show.KEY_MAIN_FIELD_4, mainField4); + * @param {String} field4 - The text that should be displayed on the second "page" second display line. If this text + * is not set, the text of mainField4 stays unchanged. If this text is empty "", the field + * will be cleared. + * @return {Show} + */ + setMainField4 (field4) { + this.setParameter(Show.KEY_MAIN_FIELD_4, field4); return this; } /** - * @return {String} - */ + * @return {String} + */ getMainField4 () { return this.getParameter(Show.KEY_MAIN_FIELD_4); } /** - * @param {TextAlignment} menuParams - * @return {Show} - */ + * @param {TextAlignment} alignment - Specifies how mainField1 and mainField2 texts should be aligned on display. If + * omitted, texts will be centered. + * @return {Show} + */ setAlignment (alignment) { this.validateType(TextAlignment, alignment); - this.setParameter(Show.KEY_ALIGNMENT, alignment); return this; } /** - * @return {TextAlignment} - */ + * @return {TextAlignment} + */ getAlignment () { return this.getObject(TextAlignment, Show.KEY_ALIGNMENT); } /** - * @param {String} statusBar - * @return {Show} - */ - setStatusBar (statusBar) { - this.setParameter(Show.KEY_STATUS_BAR, statusBar); + * @param {String} bar - Requires investigation regarding the nav display capabilities. Potentially lower + * lowerStatusBar, upperStatusBar, titleBar, etc. + * @return {Show} + */ + setStatusBar (bar) { + this.setParameter(Show.KEY_STATUS_BAR, bar); return this; } /** - * @return {String} - */ + * @return {String} + */ getStatusBar () { return this.getParameter(Show.KEY_STATUS_BAR); } /** - * @param {String} mediaClock - * @return {Show} - */ - setMediaClock (mediaClock) { - this.setParameter(Show.KEY_MEDIA_CLOCK, mediaClock); + * @param {String} clock - Text value for MediaClock field. Has to be properly formatted by Mobile App according to + * the module's capabilities. If this text is set, any automatic media clock updates + * previously set with SetMediaClockTimer will be stopped. + * @return {Show} + */ + setMediaClock (clock) { + this.setParameter(Show.KEY_MEDIA_CLOCK, clock); return this; } /** - * @return {String} - */ + * @return {String} + */ getMediaClock () { return this.getParameter(Show.KEY_MEDIA_CLOCK); } /** - * @param {String} mediaTrack - * @return {Show} - */ - setMediaTrack (mediaTrack) { - this.setParameter(Show.KEY_MEDIA_TRACK, mediaTrack); + * @param {String} track - The text that should be displayed in the track field. If this text is not set, the text + * of mediaTrack stays unchanged. If this text is empty "", the field will be cleared. + * @return {Show} + */ + setMediaTrack (track) { + this.setParameter(Show.KEY_MEDIA_TRACK, track); return this; } /** - * @return {String} - */ + * @return {String} + */ getMediaTrack () { return this.getParameter(Show.KEY_MEDIA_TRACK); } /** - * @param {Image} graphic - * @return {Show} - */ + * @param {Image} graphic - Image struct determining whether static or dynamic image to display in app. If omitted + * on supported displays, the displayed graphic shall not change. + * @return {Show} + */ setGraphic (graphic) { this.validateType(Image, graphic); - this.setParameter(Show.KEY_GRAPHIC, graphic); return this; } /** - * @return {Image} - */ + * @return {Image} + */ getGraphic () { return this.getObject(Image, Show.KEY_GRAPHIC); } /** - * @param {Image} secondaryGraphic - * @return {Show} - */ - setSecondaryGraphic (secondaryGraphic) { - this.validateType(Image, secondaryGraphic); - - this.setParameter(Show.KEY_SECONDARY_GRAPHIC, secondaryGraphic); + * @param {Image} graphic - Image struct determining whether static or dynamic secondary image to display in app. If + * omitted on supported displays, the displayed secondary graphic shall not change. + * @return {Show} + */ + setSecondaryGraphic (graphic) { + this.validateType(Image, graphic); + this.setParameter(Show.KEY_SECONDARY_GRAPHIC, graphic); return this; } /** - * @return {Image} - */ + * @return {Image} + */ getSecondaryGraphic () { return this.getObject(Image, Show.KEY_SECONDARY_GRAPHIC); } /** - * @param {Array} softButtons - * @return {Show} - */ - setSoftButtons (softButtons) { - // TODO make this work for arrays - // this.validateType(SoftButton, softButtons); - - this.setParameter(Show.KEY_SOFT_BUTTONS, softButtons); + * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, the currently + * displayed SoftButton values will not change. + * @return {Show} + */ + setSoftButtons (buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(Show.KEY_SOFT_BUTTONS, buttons); return this; } /** - * @return {Array} - */ + * @return {SoftButton[]} + */ getSoftButtons () { return this.getObject(SoftButton, Show.KEY_SOFT_BUTTONS); } /** - * @param {Array} customPresets - * @return {Show} - */ - setCustomPresets (customPresets) { - this.setParameter(Show.KEY_CUSTOM_PRESETS, customPresets); + * @param {String[]} presets - App labeled on-screen presets (i.e. on-screen media presets or dynamic search + * suggestions). If omitted on supported displays, the presets will be shown as not + * defined. + * @return {Show} + */ + setCustomPresets (presets) { + this.setParameter(Show.KEY_CUSTOM_PRESETS, presets); return this; } /** - * @return {Array} - */ + * @return {String[]} + */ getCustomPresets () { return this.getParameter(Show.KEY_CUSTOM_PRESETS); } /** - * @param {MetadataTags} metadataTags - * @return {Show} - */ - setMetadataTags (metadataTags) { - this.validateType(MetadataTags, metadataTags); - - this.setParameter(Show.KEY_METADATA_TAGS, metadataTags); + * @param {MetadataTags} tags - App defined metadata information. See MetadataStruct. Uses mainField1, mainField2, + * mainField3, mainField4. If omitted on supported displays, the currently set metadata + * tags will not change. If any text field contains no tags or the none tag, the + * metadata tag for that textfield should be removed. + * @return {Show} + */ + setMetadataTags (tags) { + this.validateType(MetadataTags, tags); + this.setParameter(Show.KEY_METADATA_TAGS, tags); return this; } /** - * @return {MetadataTags} - */ + * @return {MetadataTags} + */ getMetadataTags () { return this.getObject(MetadataTags, Show.KEY_METADATA_TAGS); } /** - * @param {String} templateTitle - * @return {Show} - */ - setTemplateTitle (templateTitle) { - this.setParameter(Show.KEY_TEMPLATE_TITLE, templateTitle); + * @param {String} title - The title of the new template that will be displayed. How this will be displayed is + * dependent on the OEM design and implementation of the template. + * @return {Show} + */ + setTemplateTitle (title) { + this.setParameter(Show.KEY_TEMPLATE_TITLE, title); return this; } /** - * @return {String} - */ + * @return {String} + */ getTemplateTitle () { return this.getParameter(Show.KEY_TEMPLATE_TITLE); } /** - * @param {Number} windowID - * @return {Show} - */ - setWindowID (windowID) { - this.setParameter(Show.KEY_WINDOW_ID, windowID); + * @param {Number} id - This is the unique ID assigned to the window that this RPC is intended. If this param is not + * included, it will be assumed that this request is specifically for the main window on the + * main display. See PredefinedWindows enum. + * @return {Show} + */ + setWindowID (id) { + this.setParameter(Show.KEY_WINDOW_ID, id); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getWindowID () { return this.getParameter(Show.KEY_WINDOW_ID); } + + /** + * @param {TemplateConfiguration} configuration - Used to set an alternate template layout to a window. + * @return {Show} + */ + setTemplateConfiguration (configuration) { + this.validateType(TemplateConfiguration, configuration); + this.setParameter(Show.KEY_TEMPLATE_CONFIGURATION, configuration); + return this; + } + + /** + * @return {TemplateConfiguration} + */ + getTemplateConfiguration () { + return this.getObject(TemplateConfiguration, Show.KEY_TEMPLATE_CONFIGURATION); + } } Show.KEY_MAIN_FIELD_1 = 'mainField1'; @@ -315,5 +353,6 @@ Show.KEY_CUSTOM_PRESETS = 'customPresets'; Show.KEY_METADATA_TAGS = 'metadataTags'; Show.KEY_TEMPLATE_TITLE = 'templateTitle'; Show.KEY_WINDOW_ID = 'windowID'; +Show.KEY_TEMPLATE_CONFIGURATION = 'templateConfiguration'; -export { Show }; +export { Show }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ShowAppMenu.js b/lib/js/src/rpc/messages/ShowAppMenu.js new file mode 100644 index 00000000..76915927 --- /dev/null +++ b/lib/js/src/rpc/messages/ShowAppMenu.js @@ -0,0 +1,69 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Shows the built in menu view + */ +class ShowAppMenu extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ShowAppMenu); + } + + /** + * @param {Number} id - If omitted the HMI opens the app's menu. If set to a sub-menu ID the HMI opens the + * corresponding sub-menu previously added using `AddSubMenu`. + * @return {ShowAppMenu} + */ + setMenuID (id) { + this.setParameter(ShowAppMenu.KEY_MENU_ID, id); + return this; + } + + /** + * @return {Number} + */ + getMenuID () { + return this.getParameter(ShowAppMenu.KEY_MENU_ID); + } +} + +ShowAppMenu.KEY_MENU_ID = 'menuID'; + +export { ShowAppMenu }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ShowAppMenuResponse.js b/lib/js/src/rpc/messages/ShowAppMenuResponse.js new file mode 100644 index 00000000..af63f17f --- /dev/null +++ b/lib/js/src/rpc/messages/ShowAppMenuResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ShowAppMenuResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ShowAppMenu); + } +} + + +export { ShowAppMenuResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ShowConstantTBT.js b/lib/js/src/rpc/messages/ShowConstantTBT.js new file mode 100644 index 00000000..0b2ceb37 --- /dev/null +++ b/lib/js/src/rpc/messages/ShowConstantTBT.js @@ -0,0 +1,246 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { SoftButton } from '../structs/SoftButton.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { Image } from '../structs/Image.js'; + +class ShowConstantTBT extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ShowConstantTBT); + } + + /** + * @param {String} text1 + * @return {ShowConstantTBT} + */ + setNavigationText1 (text1) { + this.setParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_1, text1); + return this; + } + + /** + * @return {String} + */ + getNavigationText1 () { + return this.getParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_1); + } + + /** + * @param {String} text2 + * @return {ShowConstantTBT} + */ + setNavigationText2 (text2) { + this.setParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_2, text2); + return this; + } + + /** + * @return {String} + */ + getNavigationText2 () { + return this.getParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_2); + } + + /** + * @param {String} eta + * @return {ShowConstantTBT} + */ + setEta (eta) { + this.setParameter(ShowConstantTBT.KEY_ETA, eta); + return this; + } + + /** + * @return {String} + */ + getEta () { + return this.getParameter(ShowConstantTBT.KEY_ETA); + } + + /** + * @param {String} destination + * @return {ShowConstantTBT} + */ + setTimeToDestination (destination) { + this.setParameter(ShowConstantTBT.KEY_TIME_TO_DESTINATION, destination); + return this; + } + + /** + * @return {String} + */ + getTimeToDestination () { + return this.getParameter(ShowConstantTBT.KEY_TIME_TO_DESTINATION); + } + + /** + * @param {String} distance + * @return {ShowConstantTBT} + */ + setTotalDistance (distance) { + this.setParameter(ShowConstantTBT.KEY_TOTAL_DISTANCE, distance); + return this; + } + + /** + * @return {String} + */ + getTotalDistance () { + return this.getParameter(ShowConstantTBT.KEY_TOTAL_DISTANCE); + } + + /** + * @param {Image} icon + * @return {ShowConstantTBT} + */ + setTurnIcon (icon) { + this.validateType(Image, icon); + this.setParameter(ShowConstantTBT.KEY_TURN_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getTurnIcon () { + return this.getObject(Image, ShowConstantTBT.KEY_TURN_ICON); + } + + /** + * @param {Image} icon + * @return {ShowConstantTBT} + */ + setNextTurnIcon (icon) { + this.validateType(Image, icon); + this.setParameter(ShowConstantTBT.KEY_NEXT_TURN_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getNextTurnIcon () { + return this.getObject(Image, ShowConstantTBT.KEY_NEXT_TURN_ICON); + } + + /** + * @param {Number} maneuver - Fraction of distance till next maneuver (starting from when AlertManeuver is + * triggered). Used to calculate progress bar. + * @return {ShowConstantTBT} + */ + setDistanceToManeuver (maneuver) { + this.setParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER, maneuver); + return this; + } + + /** + * @return {Number} + */ + getDistanceToManeuver () { + return this.getParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER); + } + + /** + * @param {Number} scale - Distance till next maneuver (starting from) from previous maneuver. Used to calculate + * progress bar. + * @return {ShowConstantTBT} + */ + setDistanceToManeuverScale (scale) { + this.setParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE, scale); + return this; + } + + /** + * @return {Number} + */ + getDistanceToManeuverScale () { + return this.getParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE); + } + + /** + * @param {Boolean} complete - If and when a maneuver has completed while an AlertManeuver is active, the app must + * send this value set to TRUE in order to clear the AlertManeuver overlay. If omitted + * the value will be assumed as FALSE. + * @return {ShowConstantTBT} + */ + setManeuverComplete (complete) { + this.setParameter(ShowConstantTBT.KEY_MANEUVER_COMPLETE, complete); + return this; + } + + /** + * @return {Boolean} + */ + getManeuverComplete () { + return this.getParameter(ShowConstantTBT.KEY_MANEUVER_COMPLETE); + } + + /** + * @param {SoftButton[]} buttons - Three dynamic SoftButtons available (first SoftButton is fixed to "Turns"). If + * omitted on supported displays, the currently displayed SoftButton values will not + * change. + * @return {ShowConstantTBT} + */ + setSoftButtons (buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(ShowConstantTBT.KEY_SOFT_BUTTONS, buttons); + return this; + } + + /** + * @return {SoftButton[]} + */ + getSoftButtons () { + return this.getObject(SoftButton, ShowConstantTBT.KEY_SOFT_BUTTONS); + } +} + +ShowConstantTBT.KEY_NAVIGATION_TEXT_1 = 'navigationText1'; +ShowConstantTBT.KEY_NAVIGATION_TEXT_2 = 'navigationText2'; +ShowConstantTBT.KEY_ETA = 'eta'; +ShowConstantTBT.KEY_TIME_TO_DESTINATION = 'timeToDestination'; +ShowConstantTBT.KEY_TOTAL_DISTANCE = 'totalDistance'; +ShowConstantTBT.KEY_TURN_ICON = 'turnIcon'; +ShowConstantTBT.KEY_NEXT_TURN_ICON = 'nextTurnIcon'; +ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER = 'distanceToManeuver'; +ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE = 'distanceToManeuverScale'; +ShowConstantTBT.KEY_MANEUVER_COMPLETE = 'maneuverComplete'; +ShowConstantTBT.KEY_SOFT_BUTTONS = 'softButtons'; + +export { ShowConstantTBT }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ShowConstantTBTResponse.js b/lib/js/src/rpc/messages/ShowConstantTBTResponse.js new file mode 100644 index 00000000..fd46cc22 --- /dev/null +++ b/lib/js/src/rpc/messages/ShowConstantTBTResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class ShowConstantTBTResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.ShowConstantTBT); + } +} + + +export { ShowConstantTBTResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/ShowResponse.js b/lib/js/src/rpc/messages/ShowResponse.js index 0b636fc8..2a62a053 100644 --- a/lib/js/src/rpc/messages/ShowResponse.js +++ b/lib/js/src/rpc/messages/ShowResponse.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,17 +31,18 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcResponse } from '../RpcResponse.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; class ShowResponse extends RpcResponse { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.Show); } } -export { ShowResponse }; + +export { ShowResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/Slider.js b/lib/js/src/rpc/messages/Slider.js new file mode 100644 index 00000000..54a28e65 --- /dev/null +++ b/lib/js/src/rpc/messages/Slider.js @@ -0,0 +1,158 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Creates a full screen or pop-up overlay (depending on platform) with a single user controlled slider. + */ +class Slider extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.Slider); + } + + /** + * @param {Number} ticks - Number of selectable items on a horizontal axis + * @return {Slider} + */ + setNumTicks (ticks) { + this.setParameter(Slider.KEY_NUM_TICKS, ticks); + return this; + } + + /** + * @return {Number} + */ + getNumTicks () { + return this.getParameter(Slider.KEY_NUM_TICKS); + } + + /** + * @param {Number} position - Initial position of slider control (cannot exceed numTicks) + * @return {Slider} + */ + setPosition (position) { + this.setParameter(Slider.KEY_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getPosition () { + return this.getParameter(Slider.KEY_POSITION); + } + + /** + * @param {String} header - Text header to display + * @return {Slider} + */ + setSliderHeader (header) { + this.setParameter(Slider.KEY_SLIDER_HEADER, header); + return this; + } + + /** + * @return {String} + */ + getSliderHeader () { + return this.getParameter(Slider.KEY_SLIDER_HEADER); + } + + /** + * @param {String[]} footer - Text footer to display (meant to display min/max threshold descriptors). For a static + * text footer, only one footer string shall be provided in the array. For a dynamic text + * footer, the number of footer text string in the array must match the numTicks value. + * For a dynamic text footer, text array string should correlate with potential slider + * position index. If omitted on supported displays, no footer text shall be displayed. + * @return {Slider} + */ + setSliderFooter (footer) { + this.setParameter(Slider.KEY_SLIDER_FOOTER, footer); + return this; + } + + /** + * @return {String[]} + */ + getSliderFooter () { + return this.getParameter(Slider.KEY_SLIDER_FOOTER); + } + + /** + * @param {Number} timeout - App defined timeout. Indicates how long of a timeout from the last action (i.e. sliding + * control resets timeout). If omitted, the value is set to 10000. + * @return {Slider} + */ + setTimeout (timeout) { + this.setParameter(Slider.KEY_TIMEOUT, timeout); + return this; + } + + /** + * @return {Number} + */ + getTimeout () { + return this.getParameter(Slider.KEY_TIMEOUT); + } + + /** + * @param {Number} id - An ID for this specific Slider to allow cancellation through the `CancelInteraction` RPC. + * @return {Slider} + */ + setCancelID (id) { + this.setParameter(Slider.KEY_CANCEL_ID, id); + return this; + } + + /** + * @return {Number} + */ + getCancelID () { + return this.getParameter(Slider.KEY_CANCEL_ID); + } +} + +Slider.KEY_NUM_TICKS = 'numTicks'; +Slider.KEY_POSITION = 'position'; +Slider.KEY_SLIDER_HEADER = 'sliderHeader'; +Slider.KEY_SLIDER_FOOTER = 'sliderFooter'; +Slider.KEY_TIMEOUT = 'timeout'; +Slider.KEY_CANCEL_ID = 'cancelID'; + +export { Slider }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SliderResponse.js b/lib/js/src/rpc/messages/SliderResponse.js new file mode 100644 index 00000000..b0848bb4 --- /dev/null +++ b/lib/js/src/rpc/messages/SliderResponse.js @@ -0,0 +1,66 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SliderResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.Slider); + } + + /** + * @param {Number} position - Current slider value returned when saved or canceled (aborted) This value is only + * returned for resultCodes "SAVED" or "ABORTED" + * @return {SliderResponse} + */ + setSliderPosition (position) { + this.setParameter(SliderResponse.KEY_SLIDER_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getSliderPosition () { + return this.getParameter(SliderResponse.KEY_SLIDER_POSITION); + } +} + +SliderResponse.KEY_SLIDER_POSITION = 'sliderPosition'; + +export { SliderResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/Speak.js b/lib/js/src/rpc/messages/Speak.js new file mode 100644 index 00000000..8ede0a3f --- /dev/null +++ b/lib/js/src/rpc/messages/Speak.js @@ -0,0 +1,71 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { TTSChunk } from '../structs/TTSChunk.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Speaks a text. + */ +class Speak extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.Speak); + } + + /** + * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. + * @return {Speak} + */ + setTtsChunks (chunks) { + this.validateType(TTSChunk, chunks, true); + this.setParameter(Speak.KEY_TTS_CHUNKS, chunks); + return this; + } + + /** + * @return {TTSChunk[]} + */ + getTtsChunks () { + return this.getObject(TTSChunk, Speak.KEY_TTS_CHUNKS); + } +} + +Speak.KEY_TTS_CHUNKS = 'ttsChunks'; + +export { Speak }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SpeakResponse.js b/lib/js/src/rpc/messages/SpeakResponse.js new file mode 100644 index 00000000..a25587e7 --- /dev/null +++ b/lib/js/src/rpc/messages/SpeakResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SpeakResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.Speak); + } +} + + +export { SpeakResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SubscribeButton.js b/lib/js/src/rpc/messages/SubscribeButton.js new file mode 100644 index 00000000..2028ce2b --- /dev/null +++ b/lib/js/src/rpc/messages/SubscribeButton.js @@ -0,0 +1,71 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { ButtonName } from '../enums/ButtonName.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Subscribes to built-in HMI buttons. The application will be notified by the OnButtonEvent and OnButtonPress. To + * unsubscribe the notifications, use unsubscribeButton. + */ +class SubscribeButton extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SubscribeButton); + } + + /** + * @param {ButtonName} name - Name of the button to subscribe. + * @return {SubscribeButton} + */ + setButtonName (name) { + this.validateType(ButtonName, name); + this.setParameter(SubscribeButton.KEY_BUTTON_NAME, name); + return this; + } + + /** + * @return {ButtonName} + */ + getButtonName () { + return this.getObject(ButtonName, SubscribeButton.KEY_BUTTON_NAME); + } +} + +SubscribeButton.KEY_BUTTON_NAME = 'buttonName'; + +export { SubscribeButton }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SubscribeButtonResponse.js b/lib/js/src/rpc/messages/SubscribeButtonResponse.js new file mode 100644 index 00000000..517f779b --- /dev/null +++ b/lib/js/src/rpc/messages/SubscribeButtonResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SubscribeButtonResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SubscribeButton); + } +} + + +export { SubscribeButtonResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SubscribeVehicleData.js b/lib/js/src/rpc/messages/SubscribeVehicleData.js new file mode 100644 index 00000000..37134212 --- /dev/null +++ b/lib/js/src/rpc/messages/SubscribeVehicleData.js @@ -0,0 +1,546 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Subscribes for specific published data items. The data will be only sent if it has changed. The application will be + * notified by the onVehicleData notification whenever new data is available. To unsubscribe the notifications, use + * unsubscribe with the same subscriptionType. + */ +class SubscribeVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SubscribeVehicleData); + } + + /** + * @param {Boolean} gps - See GPSData + * @return {SubscribeVehicleData} + */ + setGps (gps) { + this.setParameter(SubscribeVehicleData.KEY_GPS, gps); + return this; + } + + /** + * @return {Boolean} + */ + getGps () { + return this.getParameter(SubscribeVehicleData.KEY_GPS); + } + + /** + * @param {Boolean} speed - The vehicle speed in kilometers per hour + * @return {SubscribeVehicleData} + */ + setSpeed (speed) { + this.setParameter(SubscribeVehicleData.KEY_SPEED, speed); + return this; + } + + /** + * @return {Boolean} + */ + getSpeed () { + return this.getParameter(SubscribeVehicleData.KEY_SPEED); + } + + /** + * @param {Boolean} rpm - The number of revolutions per minute of the engine + * @return {SubscribeVehicleData} + */ + setRpm (rpm) { + this.setParameter(SubscribeVehicleData.KEY_RPM, rpm); + return this; + } + + /** + * @return {Boolean} + */ + getRpm () { + return this.getParameter(SubscribeVehicleData.KEY_RPM); + } + + /** + * @param {Boolean} level - The fuel level in the tank (percentage) + * @return {SubscribeVehicleData} + */ + setFuelLevel (level) { + this.setParameter(SubscribeVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + + /** + * @return {Boolean} + */ + getFuelLevel () { + return this.getParameter(SubscribeVehicleData.KEY_FUEL_LEVEL); + } + + /** + * @param {Boolean} level_state - The fuel level state + * @return {SubscribeVehicleData} + */ + setFuelLevel_State (level_state) { + this.setParameter(SubscribeVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + + /** + * @return {Boolean} + */ + getFuelLevel_State () { + return this.getParameter(SubscribeVehicleData.KEY_FUEL_LEVEL_STATE); + } + + /** + * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres + * @return {SubscribeVehicleData} + */ + setInstantFuelConsumption (consumption) { + this.setParameter(SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + + /** + * @return {Boolean} + */ + getInstantFuelConsumption () { + return this.getParameter(SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + + /** + * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {SubscribeVehicleData} + */ + setFuelRange (range) { + this.setParameter(SubscribeVehicleData.KEY_FUEL_RANGE, range); + return this; + } + + /** + * @return {Boolean} + */ + getFuelRange () { + return this.getParameter(SubscribeVehicleData.KEY_FUEL_RANGE); + } + + /** + * @param {Boolean} temperature - The external temperature in degrees celsius + * @return {SubscribeVehicleData} + */ + setExternalTemperature (temperature) { + this.setParameter(SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Boolean} + */ + getExternalTemperature () { + return this.getParameter(SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + + /** + * @param {Boolean} signal - See TurnSignal + * @return {SubscribeVehicleData} + */ + setTurnSignal (signal) { + this.setParameter(SubscribeVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + + /** + * @return {Boolean} + */ + getTurnSignal () { + return this.getParameter(SubscribeVehicleData.KEY_TURN_SIGNAL); + } + + /** + * @param {Boolean} prndl - See PRNDL + * @return {SubscribeVehicleData} + */ + setPrndl (prndl) { + this.setParameter(SubscribeVehicleData.KEY_PRNDL, prndl); + return this; + } + + /** + * @return {Boolean} + */ + getPrndl () { + return this.getParameter(SubscribeVehicleData.KEY_PRNDL); + } + + /** + * @param {Boolean} pressure - See TireStatus + * @return {SubscribeVehicleData} + */ + setTirePressure (pressure) { + this.setParameter(SubscribeVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + + /** + * @return {Boolean} + */ + getTirePressure () { + return this.getParameter(SubscribeVehicleData.KEY_TIRE_PRESSURE); + } + + /** + * @param {Boolean} odometer - Odometer in km + * @return {SubscribeVehicleData} + */ + setOdometer (odometer) { + this.setParameter(SubscribeVehicleData.KEY_ODOMETER, odometer); + return this; + } + + /** + * @return {Boolean} + */ + getOdometer () { + return this.getParameter(SubscribeVehicleData.KEY_ODOMETER); + } + + /** + * @param {Boolean} status - The status of the seat belts + * @return {SubscribeVehicleData} + */ + setBeltStatus (status) { + this.setParameter(SubscribeVehicleData.KEY_BELT_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getBeltStatus () { + return this.getParameter(SubscribeVehicleData.KEY_BELT_STATUS); + } + + /** + * @param {Boolean} information - The body information including power modes + * @return {SubscribeVehicleData} + */ + setBodyInformation (information) { + this.setParameter(SubscribeVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + + /** + * @return {Boolean} + */ + getBodyInformation () { + return this.getParameter(SubscribeVehicleData.KEY_BODY_INFORMATION); + } + + /** + * @param {Boolean} status - The device status including signal and battery strength + * @return {SubscribeVehicleData} + */ + setDeviceStatus (status) { + this.setParameter(SubscribeVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getDeviceStatus () { + return this.getParameter(SubscribeVehicleData.KEY_DEVICE_STATUS); + } + + /** + * @param {Boolean} braking - The status of the brake pedal + * @return {SubscribeVehicleData} + */ + setDriverBraking (braking) { + this.setParameter(SubscribeVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + + /** + * @return {Boolean} + */ + getDriverBraking () { + return this.getParameter(SubscribeVehicleData.KEY_DRIVER_BRAKING); + } + + /** + * @param {Boolean} status - The status of the wipers + * @return {SubscribeVehicleData} + */ + setWiperStatus (status) { + this.setParameter(SubscribeVehicleData.KEY_WIPER_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getWiperStatus () { + return this.getParameter(SubscribeVehicleData.KEY_WIPER_STATUS); + } + + /** + * @param {Boolean} status - Status of the head lamps + * @return {SubscribeVehicleData} + */ + setHeadLampStatus (status) { + this.setParameter(SubscribeVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getHeadLampStatus () { + return this.getParameter(SubscribeVehicleData.KEY_HEAD_LAMP_STATUS); + } + + /** + * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {SubscribeVehicleData} + */ + setEngineTorque (torque) { + this.setParameter(SubscribeVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + + /** + * @return {Boolean} + */ + getEngineTorque () { + return this.getParameter(SubscribeVehicleData.KEY_ENGINE_TORQUE); + } + + /** + * @param {Boolean} position - Accelerator pedal position (percentage depressed) + * @return {SubscribeVehicleData} + */ + setAccPedalPosition (position) { + this.setParameter(SubscribeVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + + /** + * @return {Boolean} + */ + getAccPedalPosition () { + return this.getParameter(SubscribeVehicleData.KEY_ACC_PEDAL_POSITION); + } + + /** + * @param {Boolean} angle - Current angle of the steering wheel (in deg) + * @return {SubscribeVehicleData} + */ + setSteeringWheelAngle (angle) { + this.setParameter(SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + + /** + * @return {Boolean} + */ + getSteeringWheelAngle () { + return this.getParameter(SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + + /** + * @param {Boolean} life - The estimated percentage of remaining oil life of the engine. + * @return {SubscribeVehicleData} + */ + setEngineOilLife (life) { + this.setParameter(SubscribeVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + + /** + * @return {Boolean} + */ + getEngineOilLife () { + return this.getParameter(SubscribeVehicleData.KEY_ENGINE_OIL_LIFE); + } + + /** + * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {SubscribeVehicleData} + */ + setElectronicParkBrakeStatus (status) { + this.setParameter(SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getElectronicParkBrakeStatus () { + return this.getParameter(SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + + /** + * @param {Boolean} id - Parameter used by cloud apps to identify a head unit + * @return {SubscribeVehicleData} + */ + setCloudAppVehicleID (id) { + this.setParameter(SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + + /** + * @return {Boolean} + */ + getCloudAppVehicleID () { + return this.getParameter(SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + + /** + * @param {Boolean} info - Emergency Call notification and confirmation data + * @return {SubscribeVehicleData} + */ + setECallInfo (info) { + this.setParameter(SubscribeVehicleData.KEY_E_CALL_INFO, info); + return this; + } + + /** + * @return {Boolean} + */ + getECallInfo () { + return this.getParameter(SubscribeVehicleData.KEY_E_CALL_INFO); + } + + /** + * @param {Boolean} status - The status of the air bags + * @return {SubscribeVehicleData} + */ + setAirbagStatus (status) { + this.setParameter(SubscribeVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getAirbagStatus () { + return this.getParameter(SubscribeVehicleData.KEY_AIRBAG_STATUS); + } + + /** + * @param {Boolean} event - Information related to an emergency event (and if it occurred) + * @return {SubscribeVehicleData} + */ + setEmergencyEvent (event) { + this.setParameter(SubscribeVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + + /** + * @return {Boolean} + */ + getEmergencyEvent () { + return this.getParameter(SubscribeVehicleData.KEY_EMERGENCY_EVENT); + } + + /** + * @param {Boolean} status - The status modes of the cluster + * @return {SubscribeVehicleData} + */ + setClusterModeStatus (status) { + this.setParameter(SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getClusterModeStatus () { + return this.getParameter(SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS); + } + + /** + * @param {Boolean} key - Information related to the MyKey feature + * @return {SubscribeVehicleData} + */ + setMyKey (key) { + this.setParameter(SubscribeVehicleData.KEY_MY_KEY, key); + return this; + } + + /** + * @return {Boolean} + */ + getMyKey () { + return this.getParameter(SubscribeVehicleData.KEY_MY_KEY); + } +} + +SubscribeVehicleData.KEY_GPS = 'gps'; +SubscribeVehicleData.KEY_SPEED = 'speed'; +SubscribeVehicleData.KEY_RPM = 'rpm'; +SubscribeVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; +SubscribeVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; +SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; +SubscribeVehicleData.KEY_FUEL_RANGE = 'fuelRange'; +SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; +SubscribeVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; +SubscribeVehicleData.KEY_PRNDL = 'prndl'; +SubscribeVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; +SubscribeVehicleData.KEY_ODOMETER = 'odometer'; +SubscribeVehicleData.KEY_BELT_STATUS = 'beltStatus'; +SubscribeVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; +SubscribeVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; +SubscribeVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; +SubscribeVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; +SubscribeVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; +SubscribeVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; +SubscribeVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; +SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; +SubscribeVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; +SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; +SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; +SubscribeVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; +SubscribeVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; +SubscribeVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; +SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; +SubscribeVehicleData.KEY_MY_KEY = 'myKey'; + +export { SubscribeVehicleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SubscribeVehicleDataResponse.js b/lib/js/src/rpc/messages/SubscribeVehicleDataResponse.js new file mode 100644 index 00000000..9189ccee --- /dev/null +++ b/lib/js/src/rpc/messages/SubscribeVehicleDataResponse.js @@ -0,0 +1,572 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; +import { VehicleDataResult } from '../structs/VehicleDataResult.js'; + +class SubscribeVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SubscribeVehicleData); + } + + /** + * @param {VehicleDataResult} gps - See GPSData + * @return {SubscribeVehicleDataResponse} + */ + setGps (gps) { + this.validateType(VehicleDataResult, gps); + this.setParameter(SubscribeVehicleDataResponse.KEY_GPS, gps); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getGps () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_GPS); + } + + /** + * @param {VehicleDataResult} speed - The vehicle speed in kilometers per hour + * @return {SubscribeVehicleDataResponse} + */ + setSpeed (speed) { + this.validateType(VehicleDataResult, speed); + this.setParameter(SubscribeVehicleDataResponse.KEY_SPEED, speed); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getSpeed () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_SPEED); + } + + /** + * @param {VehicleDataResult} rpm - The number of revolutions per minute of the engine + * @return {SubscribeVehicleDataResponse} + */ + setRpm (rpm) { + this.validateType(VehicleDataResult, rpm); + this.setParameter(SubscribeVehicleDataResponse.KEY_RPM, rpm); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getRpm () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_RPM); + } + + /** + * @param {VehicleDataResult} level - The fuel level in the tank (percentage) + * @return {SubscribeVehicleDataResponse} + */ + setFuelLevel (level) { + this.validateType(VehicleDataResult, level); + this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_LEVEL, level); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getFuelLevel () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_LEVEL); + } + + /** + * @param {VehicleDataResult} level_state - The fuel level state + * @return {SubscribeVehicleDataResponse} + */ + setFuelLevel_State (level_state) { + this.validateType(VehicleDataResult, level_state); + this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getFuelLevel_State () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE); + } + + /** + * @param {VehicleDataResult} consumption - The instantaneous fuel consumption in microlitres + * @return {SubscribeVehicleDataResponse} + */ + setInstantFuelConsumption (consumption) { + this.validateType(VehicleDataResult, consumption); + this.setParameter(SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getInstantFuelConsumption () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION); + } + + /** + * @param {VehicleDataResult} range - The estimate range in KM the vehicle can travel based on fuel level and + * consumption + * @return {SubscribeVehicleDataResponse} + */ + setFuelRange (range) { + this.validateType(VehicleDataResult, range); + this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_RANGE, range); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getFuelRange () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_RANGE); + } + + /** + * @param {VehicleDataResult} temperature - The external temperature in degrees celsius. + * @return {SubscribeVehicleDataResponse} + */ + setExternalTemperature (temperature) { + this.validateType(VehicleDataResult, temperature); + this.setParameter(SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getExternalTemperature () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE); + } + + /** + * @param {VehicleDataResult} signal - See TurnSignal + * @return {SubscribeVehicleDataResponse} + */ + setTurnSignal (signal) { + this.validateType(VehicleDataResult, signal); + this.setParameter(SubscribeVehicleDataResponse.KEY_TURN_SIGNAL, signal); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getTurnSignal () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_TURN_SIGNAL); + } + + /** + * @param {VehicleDataResult} prndl - See PRNDL + * @return {SubscribeVehicleDataResponse} + */ + setPrndl (prndl) { + this.validateType(VehicleDataResult, prndl); + this.setParameter(SubscribeVehicleDataResponse.KEY_PRNDL, prndl); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getPrndl () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_PRNDL); + } + + /** + * @param {VehicleDataResult} pressure - See TireStatus + * @return {SubscribeVehicleDataResponse} + */ + setTirePressure (pressure) { + this.validateType(VehicleDataResult, pressure); + this.setParameter(SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE, pressure); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getTirePressure () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE); + } + + /** + * @param {VehicleDataResult} odometer - Odometer in km + * @return {SubscribeVehicleDataResponse} + */ + setOdometer (odometer) { + this.validateType(VehicleDataResult, odometer); + this.setParameter(SubscribeVehicleDataResponse.KEY_ODOMETER, odometer); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getOdometer () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ODOMETER); + } + + /** + * @param {VehicleDataResult} status - The status of the seat belts + * @return {SubscribeVehicleDataResponse} + */ + setBeltStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_BELT_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getBeltStatus () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_BELT_STATUS); + } + + /** + * @param {VehicleDataResult} information - The body information including power modes + * @return {SubscribeVehicleDataResponse} + */ + setBodyInformation (information) { + this.validateType(VehicleDataResult, information); + this.setParameter(SubscribeVehicleDataResponse.KEY_BODY_INFORMATION, information); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getBodyInformation () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_BODY_INFORMATION); + } + + /** + * @param {VehicleDataResult} status - The device status including signal and battery strength + * @return {SubscribeVehicleDataResponse} + */ + setDeviceStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_DEVICE_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getDeviceStatus () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_DEVICE_STATUS); + } + + /** + * @param {VehicleDataResult} braking - The status of the brake pedal + * @return {SubscribeVehicleDataResponse} + */ + setDriverBraking (braking) { + this.validateType(VehicleDataResult, braking); + this.setParameter(SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING, braking); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getDriverBraking () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING); + } + + /** + * @param {VehicleDataResult} status - The status of the wipers + * @return {SubscribeVehicleDataResponse} + */ + setWiperStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_WIPER_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getWiperStatus () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_WIPER_STATUS); + } + + /** + * @param {VehicleDataResult} status - Status of the head lamps + * @return {SubscribeVehicleDataResponse} + */ + setHeadLampStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getHeadLampStatus () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS); + } + + /** + * @param {VehicleDataResult} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {SubscribeVehicleDataResponse} + */ + setEngineTorque (torque) { + this.validateType(VehicleDataResult, torque); + this.setParameter(SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE, torque); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getEngineTorque () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE); + } + + /** + * @param {VehicleDataResult} position - Accelerator pedal position (percentage depressed) + * @return {SubscribeVehicleDataResponse} + */ + setAccPedalPosition (position) { + this.validateType(VehicleDataResult, position); + this.setParameter(SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getAccPedalPosition () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION); + } + + /** + * @param {VehicleDataResult} angle - Current angle of the steering wheel (in deg) + * @return {SubscribeVehicleDataResponse} + */ + setSteeringWheelAngle (angle) { + this.validateType(VehicleDataResult, angle); + this.setParameter(SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getSteeringWheelAngle () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE); + } + + /** + * @param {VehicleDataResult} life - The estimated percentage of remaining oil life of the engine. + * @return {SubscribeVehicleDataResponse} + */ + setEngineOilLife (life) { + this.validateType(VehicleDataResult, life); + this.setParameter(SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getEngineOilLife () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE); + } + + /** + * @param {VehicleDataResult} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {SubscribeVehicleDataResponse} + */ + setElectronicParkBrakeStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getElectronicParkBrakeStatus () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + + /** + * @param {VehicleDataResult} id - Parameter used by cloud apps to identify a head unit + * @return {SubscribeVehicleDataResponse} + */ + setCloudAppVehicleID (id) { + this.validateType(VehicleDataResult, id); + this.setParameter(SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getCloudAppVehicleID () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID); + } + + /** + * @param {VehicleDataResult} info - Emergency Call notification and confirmation data + * @return {SubscribeVehicleDataResponse} + */ + setECallInfo (info) { + this.validateType(VehicleDataResult, info); + this.setParameter(SubscribeVehicleDataResponse.KEY_E_CALL_INFO, info); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getECallInfo () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_E_CALL_INFO); + } + + /** + * @param {VehicleDataResult} status - The status of the air bags + * @return {SubscribeVehicleDataResponse} + */ + setAirbagStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getAirbagStatus () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS); + } + + /** + * @param {VehicleDataResult} event - Information related to an emergency event (and if it occurred) + * @return {SubscribeVehicleDataResponse} + */ + setEmergencyEvent (event) { + this.validateType(VehicleDataResult, event); + this.setParameter(SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT, event); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getEmergencyEvent () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT); + } + + /** + * @param {VehicleDataResult} modes - The status modes of the cluster + * @return {SubscribeVehicleDataResponse} + */ + setClusterModes (modes) { + this.validateType(VehicleDataResult, modes); + this.setParameter(SubscribeVehicleDataResponse.KEY_CLUSTER_MODES, modes); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getClusterModes () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_CLUSTER_MODES); + } + + /** + * @param {VehicleDataResult} key - Information related to the MyKey feature + * @return {SubscribeVehicleDataResponse} + */ + setMyKey (key) { + this.validateType(VehicleDataResult, key); + this.setParameter(SubscribeVehicleDataResponse.KEY_MY_KEY, key); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getMyKey () { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_MY_KEY); + } +} + +SubscribeVehicleDataResponse.KEY_GPS = 'gps'; +SubscribeVehicleDataResponse.KEY_SPEED = 'speed'; +SubscribeVehicleDataResponse.KEY_RPM = 'rpm'; +SubscribeVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel'; +SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; +SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; +SubscribeVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange'; +SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; +SubscribeVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal'; +SubscribeVehicleDataResponse.KEY_PRNDL = 'prndl'; +SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure'; +SubscribeVehicleDataResponse.KEY_ODOMETER = 'odometer'; +SubscribeVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus'; +SubscribeVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation'; +SubscribeVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus'; +SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking'; +SubscribeVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus'; +SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; +SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque'; +SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; +SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; +SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; +SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; +SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; +SubscribeVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo'; +SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus'; +SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent'; +SubscribeVehicleDataResponse.KEY_CLUSTER_MODES = 'clusterModes'; +SubscribeVehicleDataResponse.KEY_MY_KEY = 'myKey'; + +export { SubscribeVehicleDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SubscribeWayPoints.js b/lib/js/src/rpc/messages/SubscribeWayPoints.js new file mode 100644 index 00000000..309be2c3 --- /dev/null +++ b/lib/js/src/rpc/messages/SubscribeWayPoints.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * To subscribe in getting changes for Waypoints/destinations + */ +class SubscribeWayPoints extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SubscribeWayPoints); + } +} + + +export { SubscribeWayPoints }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SubscribeWayPointsResponse.js b/lib/js/src/rpc/messages/SubscribeWayPointsResponse.js new file mode 100644 index 00000000..d2100e99 --- /dev/null +++ b/lib/js/src/rpc/messages/SubscribeWayPointsResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SubscribeWayPointsResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SubscribeWayPoints); + } +} + + +export { SubscribeWayPointsResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SystemRequest.js b/lib/js/src/rpc/messages/SystemRequest.js new file mode 100644 index 00000000..094eff86 --- /dev/null +++ b/lib/js/src/rpc/messages/SystemRequest.js @@ -0,0 +1,107 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { RequestType } from '../enums/RequestType.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * An asynchronous request from the device; binary data can be included in hybrid part of message for some requests + * (such as HTTP, Proprietary, or Authentication requests) + */ +class SystemRequest extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SystemRequest); + } + + /** + * @param {RequestType} type - The type of system request. Note that Proprietary requests should forward the binary + * data to the known proprietary module on the system. + * @return {SystemRequest} + */ + setRequestType (type) { + this.validateType(RequestType, type); + this.setParameter(SystemRequest.KEY_REQUEST_TYPE, type); + return this; + } + + /** + * @return {RequestType} + */ + getRequestType () { + return this.getObject(RequestType, SystemRequest.KEY_REQUEST_TYPE); + } + + /** + * @param {String} type - This parameter is filled for supporting OEM proprietary data exchanges. + * @return {SystemRequest} + */ + setRequestSubType (type) { + this.setParameter(SystemRequest.KEY_REQUEST_SUB_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getRequestSubType () { + return this.getParameter(SystemRequest.KEY_REQUEST_SUB_TYPE); + } + + /** + * @param {String} name - Filename of HTTP data to store in predefined system staging area. Mandatory if requestType + * is HTTP. PROPRIETARY requestType should ignore this parameter. + * @return {SystemRequest} + */ + setFileName (name) { + this.setParameter(SystemRequest.KEY_FILE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getFileName () { + return this.getParameter(SystemRequest.KEY_FILE_NAME); + } +} + +SystemRequest.KEY_REQUEST_TYPE = 'requestType'; +SystemRequest.KEY_REQUEST_SUB_TYPE = 'requestSubType'; +SystemRequest.KEY_FILE_NAME = 'fileName'; + +export { SystemRequest }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/SystemRequestResponse.js b/lib/js/src/rpc/messages/SystemRequestResponse.js new file mode 100644 index 00000000..2bb1c832 --- /dev/null +++ b/lib/js/src/rpc/messages/SystemRequestResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class SystemRequestResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.SystemRequest); + } +} + + +export { SystemRequestResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnpublishAppService.js b/lib/js/src/rpc/messages/UnpublishAppService.js new file mode 100644 index 00000000..0fcb69b1 --- /dev/null +++ b/lib/js/src/rpc/messages/UnpublishAppService.js @@ -0,0 +1,68 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Unpublish an existing service published by this application. + */ +class UnpublishAppService extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnpublishAppService); + } + + /** + * @param {String} id - The ID of the service to be unpublished. + * @return {UnpublishAppService} + */ + setServiceID (id) { + this.setParameter(UnpublishAppService.KEY_SERVICE_ID, id); + return this; + } + + /** + * @return {String} + */ + getServiceID () { + return this.getParameter(UnpublishAppService.KEY_SERVICE_ID); + } +} + +UnpublishAppService.KEY_SERVICE_ID = 'serviceID'; + +export { UnpublishAppService }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnpublishAppServiceResponse.js b/lib/js/src/rpc/messages/UnpublishAppServiceResponse.js new file mode 100644 index 00000000..6ab57439 --- /dev/null +++ b/lib/js/src/rpc/messages/UnpublishAppServiceResponse.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +/** + * The response to UnpublishAppService + */ +class UnpublishAppServiceResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnpublishAppService); + } +} + + +export { UnpublishAppServiceResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnregisterAppInterface.js b/lib/js/src/rpc/messages/UnregisterAppInterface.js index 0116a608..c754d6cb 100644 --- a/lib/js/src/rpc/messages/UnregisterAppInterface.js +++ b/lib/js/src/rpc/messages/UnregisterAppInterface.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,10 +34,15 @@ import { RpcRequest } from '../RpcRequest.js'; import { FunctionID } from '../enums/FunctionID.js'; +/** + * Closes an interface from a mobile application. After unregisterAppInterface, no commands other than + * registerAppInterface will be accepted/executed. Will fail, if no registerAppInterface was completed successfully + * before. + */ class UnregisterAppInterface extends RpcRequest { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.UnregisterAppInterface); @@ -44,4 +50,4 @@ class UnregisterAppInterface extends RpcRequest { } -export { UnregisterAppInterface }; +export { UnregisterAppInterface }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnregisterAppInterfaceResponse.js b/lib/js/src/rpc/messages/UnregisterAppInterfaceResponse.js index cb785934..983550ab 100644 --- a/lib/js/src/rpc/messages/UnregisterAppInterfaceResponse.js +++ b/lib/js/src/rpc/messages/UnregisterAppInterfaceResponse.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,17 +31,18 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcResponse } from '../RpcResponse.js'; import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; class UnregisterAppInterfaceResponse extends RpcResponse { /** - * @constructor - */ + * @constructor + */ constructor (store) { super(store); this.setFunctionName(FunctionID.UnregisterAppInterface); } } -export { UnregisterAppInterfaceResponse }; + +export { UnregisterAppInterfaceResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnsubscribeButton.js b/lib/js/src/rpc/messages/UnsubscribeButton.js new file mode 100644 index 00000000..d4dd7af9 --- /dev/null +++ b/lib/js/src/rpc/messages/UnsubscribeButton.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { ButtonName } from '../enums/ButtonName.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Unsubscribes from built-in HMI buttons. + */ +class UnsubscribeButton extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeButton); + } + + /** + * @param {ButtonName} name - Name of the button to unsubscribe. + * @return {UnsubscribeButton} + */ + setButtonName (name) { + this.validateType(ButtonName, name); + this.setParameter(UnsubscribeButton.KEY_BUTTON_NAME, name); + return this; + } + + /** + * @return {ButtonName} + */ + getButtonName () { + return this.getObject(ButtonName, UnsubscribeButton.KEY_BUTTON_NAME); + } +} + +UnsubscribeButton.KEY_BUTTON_NAME = 'buttonName'; + +export { UnsubscribeButton }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnsubscribeButtonResponse.js b/lib/js/src/rpc/messages/UnsubscribeButtonResponse.js new file mode 100644 index 00000000..386b785c --- /dev/null +++ b/lib/js/src/rpc/messages/UnsubscribeButtonResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class UnsubscribeButtonResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeButton); + } +} + + +export { UnsubscribeButtonResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnsubscribeVehicleData.js b/lib/js/src/rpc/messages/UnsubscribeVehicleData.js new file mode 100644 index 00000000..2bf5f92d --- /dev/null +++ b/lib/js/src/rpc/messages/UnsubscribeVehicleData.js @@ -0,0 +1,544 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * This function is used to unsubscribe the notifications from the subscribeVehicleData function. + */ +class UnsubscribeVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeVehicleData); + } + + /** + * @param {Boolean} gps - See GPSData + * @return {UnsubscribeVehicleData} + */ + setGps (gps) { + this.setParameter(UnsubscribeVehicleData.KEY_GPS, gps); + return this; + } + + /** + * @return {Boolean} + */ + getGps () { + return this.getParameter(UnsubscribeVehicleData.KEY_GPS); + } + + /** + * @param {Boolean} speed - The vehicle speed in kilometers per hour + * @return {UnsubscribeVehicleData} + */ + setSpeed (speed) { + this.setParameter(UnsubscribeVehicleData.KEY_SPEED, speed); + return this; + } + + /** + * @return {Boolean} + */ + getSpeed () { + return this.getParameter(UnsubscribeVehicleData.KEY_SPEED); + } + + /** + * @param {Boolean} rpm - The number of revolutions per minute of the engine + * @return {UnsubscribeVehicleData} + */ + setRpm (rpm) { + this.setParameter(UnsubscribeVehicleData.KEY_RPM, rpm); + return this; + } + + /** + * @return {Boolean} + */ + getRpm () { + return this.getParameter(UnsubscribeVehicleData.KEY_RPM); + } + + /** + * @param {Boolean} level - The fuel level in the tank (percentage) + * @return {UnsubscribeVehicleData} + */ + setFuelLevel (level) { + this.setParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + + /** + * @return {Boolean} + */ + getFuelLevel () { + return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL); + } + + /** + * @param {Boolean} level_state - The fuel level state + * @return {UnsubscribeVehicleData} + */ + setFuelLevel_State (level_state) { + this.setParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + + /** + * @return {Boolean} + */ + getFuelLevel_State () { + return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE); + } + + /** + * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres + * @return {UnsubscribeVehicleData} + */ + setInstantFuelConsumption (consumption) { + this.setParameter(UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + + /** + * @return {Boolean} + */ + getInstantFuelConsumption () { + return this.getParameter(UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + + /** + * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {UnsubscribeVehicleData} + */ + setFuelRange (range) { + this.setParameter(UnsubscribeVehicleData.KEY_FUEL_RANGE, range); + return this; + } + + /** + * @return {Boolean} + */ + getFuelRange () { + return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_RANGE); + } + + /** + * @param {Boolean} temperature - The external temperature in degrees celsius. + * @return {UnsubscribeVehicleData} + */ + setExternalTemperature (temperature) { + this.setParameter(UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Boolean} + */ + getExternalTemperature () { + return this.getParameter(UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + + /** + * @param {Boolean} signal - See TurnSignal + * @return {UnsubscribeVehicleData} + */ + setTurnSignal (signal) { + this.setParameter(UnsubscribeVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + + /** + * @return {Boolean} + */ + getTurnSignal () { + return this.getParameter(UnsubscribeVehicleData.KEY_TURN_SIGNAL); + } + + /** + * @param {Boolean} prndl - See PRNDL + * @return {UnsubscribeVehicleData} + */ + setPrndl (prndl) { + this.setParameter(UnsubscribeVehicleData.KEY_PRNDL, prndl); + return this; + } + + /** + * @return {Boolean} + */ + getPrndl () { + return this.getParameter(UnsubscribeVehicleData.KEY_PRNDL); + } + + /** + * @param {Boolean} pressure - See TireStatus + * @return {UnsubscribeVehicleData} + */ + setTirePressure (pressure) { + this.setParameter(UnsubscribeVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + + /** + * @return {Boolean} + */ + getTirePressure () { + return this.getParameter(UnsubscribeVehicleData.KEY_TIRE_PRESSURE); + } + + /** + * @param {Boolean} odometer - Odometer in km + * @return {UnsubscribeVehicleData} + */ + setOdometer (odometer) { + this.setParameter(UnsubscribeVehicleData.KEY_ODOMETER, odometer); + return this; + } + + /** + * @return {Boolean} + */ + getOdometer () { + return this.getParameter(UnsubscribeVehicleData.KEY_ODOMETER); + } + + /** + * @param {Boolean} status - The status of the seat belts + * @return {UnsubscribeVehicleData} + */ + setBeltStatus (status) { + this.setParameter(UnsubscribeVehicleData.KEY_BELT_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getBeltStatus () { + return this.getParameter(UnsubscribeVehicleData.KEY_BELT_STATUS); + } + + /** + * @param {Boolean} information - The body information including power modes + * @return {UnsubscribeVehicleData} + */ + setBodyInformation (information) { + this.setParameter(UnsubscribeVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + + /** + * @return {Boolean} + */ + getBodyInformation () { + return this.getParameter(UnsubscribeVehicleData.KEY_BODY_INFORMATION); + } + + /** + * @param {Boolean} status - The device status including signal and battery strength + * @return {UnsubscribeVehicleData} + */ + setDeviceStatus (status) { + this.setParameter(UnsubscribeVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getDeviceStatus () { + return this.getParameter(UnsubscribeVehicleData.KEY_DEVICE_STATUS); + } + + /** + * @param {Boolean} braking - The status of the brake pedal + * @return {UnsubscribeVehicleData} + */ + setDriverBraking (braking) { + this.setParameter(UnsubscribeVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + + /** + * @return {Boolean} + */ + getDriverBraking () { + return this.getParameter(UnsubscribeVehicleData.KEY_DRIVER_BRAKING); + } + + /** + * @param {Boolean} status - The status of the wipers + * @return {UnsubscribeVehicleData} + */ + setWiperStatus (status) { + this.setParameter(UnsubscribeVehicleData.KEY_WIPER_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getWiperStatus () { + return this.getParameter(UnsubscribeVehicleData.KEY_WIPER_STATUS); + } + + /** + * @param {Boolean} status - Status of the head lamps + * @return {UnsubscribeVehicleData} + */ + setHeadLampStatus (status) { + this.setParameter(UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getHeadLampStatus () { + return this.getParameter(UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS); + } + + /** + * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {UnsubscribeVehicleData} + */ + setEngineTorque (torque) { + this.setParameter(UnsubscribeVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + + /** + * @return {Boolean} + */ + getEngineTorque () { + return this.getParameter(UnsubscribeVehicleData.KEY_ENGINE_TORQUE); + } + + /** + * @param {Boolean} position - Accelerator pedal position (percentage depressed) + * @return {UnsubscribeVehicleData} + */ + setAccPedalPosition (position) { + this.setParameter(UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + + /** + * @return {Boolean} + */ + getAccPedalPosition () { + return this.getParameter(UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION); + } + + /** + * @param {Boolean} angle - Current angle of the steering wheel (in deg) + * @return {UnsubscribeVehicleData} + */ + setSteeringWheelAngle (angle) { + this.setParameter(UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + + /** + * @return {Boolean} + */ + getSteeringWheelAngle () { + return this.getParameter(UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + + /** + * @param {Boolean} life - The estimated percentage of remaining oil life of the engine. + * @return {UnsubscribeVehicleData} + */ + setEngineOilLife (life) { + this.setParameter(UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + + /** + * @return {Boolean} + */ + getEngineOilLife () { + return this.getParameter(UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE); + } + + /** + * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {UnsubscribeVehicleData} + */ + setElectronicParkBrakeStatus (status) { + this.setParameter(UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getElectronicParkBrakeStatus () { + return this.getParameter(UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + + /** + * @param {Boolean} id - Parameter used by cloud apps to identify a head unit + * @return {UnsubscribeVehicleData} + */ + setCloudAppVehicleID (id) { + this.setParameter(UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + + /** + * @return {Boolean} + */ + getCloudAppVehicleID () { + return this.getParameter(UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + + /** + * @param {Boolean} info - Emergency Call notification and confirmation data + * @return {UnsubscribeVehicleData} + */ + setECallInfo (info) { + this.setParameter(UnsubscribeVehicleData.KEY_E_CALL_INFO, info); + return this; + } + + /** + * @return {Boolean} + */ + getECallInfo () { + return this.getParameter(UnsubscribeVehicleData.KEY_E_CALL_INFO); + } + + /** + * @param {Boolean} status - The status of the air bags + * @return {UnsubscribeVehicleData} + */ + setAirbagStatus (status) { + this.setParameter(UnsubscribeVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getAirbagStatus () { + return this.getParameter(UnsubscribeVehicleData.KEY_AIRBAG_STATUS); + } + + /** + * @param {Boolean} event - Information related to an emergency event (and if it occurred) + * @return {UnsubscribeVehicleData} + */ + setEmergencyEvent (event) { + this.setParameter(UnsubscribeVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + + /** + * @return {Boolean} + */ + getEmergencyEvent () { + return this.getParameter(UnsubscribeVehicleData.KEY_EMERGENCY_EVENT); + } + + /** + * @param {Boolean} status - The status modes of the cluster + * @return {UnsubscribeVehicleData} + */ + setClusterModeStatus (status) { + this.setParameter(UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + + /** + * @return {Boolean} + */ + getClusterModeStatus () { + return this.getParameter(UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS); + } + + /** + * @param {Boolean} key - Information related to the MyKey feature + * @return {UnsubscribeVehicleData} + */ + setMyKey (key) { + this.setParameter(UnsubscribeVehicleData.KEY_MY_KEY, key); + return this; + } + + /** + * @return {Boolean} + */ + getMyKey () { + return this.getParameter(UnsubscribeVehicleData.KEY_MY_KEY); + } +} + +UnsubscribeVehicleData.KEY_GPS = 'gps'; +UnsubscribeVehicleData.KEY_SPEED = 'speed'; +UnsubscribeVehicleData.KEY_RPM = 'rpm'; +UnsubscribeVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; +UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; +UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; +UnsubscribeVehicleData.KEY_FUEL_RANGE = 'fuelRange'; +UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; +UnsubscribeVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; +UnsubscribeVehicleData.KEY_PRNDL = 'prndl'; +UnsubscribeVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; +UnsubscribeVehicleData.KEY_ODOMETER = 'odometer'; +UnsubscribeVehicleData.KEY_BELT_STATUS = 'beltStatus'; +UnsubscribeVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; +UnsubscribeVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; +UnsubscribeVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; +UnsubscribeVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; +UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; +UnsubscribeVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; +UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; +UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; +UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; +UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; +UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; +UnsubscribeVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; +UnsubscribeVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; +UnsubscribeVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; +UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; +UnsubscribeVehicleData.KEY_MY_KEY = 'myKey'; + +export { UnsubscribeVehicleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnsubscribeVehicleDataResponse.js b/lib/js/src/rpc/messages/UnsubscribeVehicleDataResponse.js new file mode 100644 index 00000000..f538f055 --- /dev/null +++ b/lib/js/src/rpc/messages/UnsubscribeVehicleDataResponse.js @@ -0,0 +1,572 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; +import { VehicleDataResult } from '../structs/VehicleDataResult.js'; + +class UnsubscribeVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeVehicleData); + } + + /** + * @param {VehicleDataResult} gps - See GPSData + * @return {UnsubscribeVehicleDataResponse} + */ + setGps (gps) { + this.validateType(VehicleDataResult, gps); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_GPS, gps); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getGps () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_GPS); + } + + /** + * @param {VehicleDataResult} speed - The vehicle speed in kilometers per hour + * @return {UnsubscribeVehicleDataResponse} + */ + setSpeed (speed) { + this.validateType(VehicleDataResult, speed); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_SPEED, speed); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getSpeed () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_SPEED); + } + + /** + * @param {VehicleDataResult} rpm - The number of revolutions per minute of the engine + * @return {UnsubscribeVehicleDataResponse} + */ + setRpm (rpm) { + this.validateType(VehicleDataResult, rpm); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_RPM, rpm); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getRpm () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_RPM); + } + + /** + * @param {VehicleDataResult} level - The fuel level in the tank (percentage) + * @return {UnsubscribeVehicleDataResponse} + */ + setFuelLevel (level) { + this.validateType(VehicleDataResult, level); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL, level); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getFuelLevel () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL); + } + + /** + * @param {VehicleDataResult} level_state - The fuel level state + * @return {UnsubscribeVehicleDataResponse} + */ + setFuelLevel_State (level_state) { + this.validateType(VehicleDataResult, level_state); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getFuelLevel_State () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE); + } + + /** + * @param {VehicleDataResult} consumption - The instantaneous fuel consumption in microlitres + * @return {UnsubscribeVehicleDataResponse} + */ + setInstantFuelConsumption (consumption) { + this.validateType(VehicleDataResult, consumption); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getInstantFuelConsumption () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION); + } + + /** + * @param {VehicleDataResult} range - The estimate range in KM the vehicle can travel based on fuel level and + * consumption + * @return {UnsubscribeVehicleDataResponse} + */ + setFuelRange (range) { + this.validateType(VehicleDataResult, range); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE, range); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getFuelRange () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE); + } + + /** + * @param {VehicleDataResult} temperature - The external temperature in degrees celsius + * @return {UnsubscribeVehicleDataResponse} + */ + setExternalTemperature (temperature) { + this.validateType(VehicleDataResult, temperature); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getExternalTemperature () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE); + } + + /** + * @param {VehicleDataResult} signal - See TurnSignal + * @return {UnsubscribeVehicleDataResponse} + */ + setTurnSignal (signal) { + this.validateType(VehicleDataResult, signal); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL, signal); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getTurnSignal () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL); + } + + /** + * @param {VehicleDataResult} prndl - See PRNDL + * @return {UnsubscribeVehicleDataResponse} + */ + setPrndl (prndl) { + this.validateType(VehicleDataResult, prndl); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_PRNDL, prndl); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getPrndl () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_PRNDL); + } + + /** + * @param {VehicleDataResult} pressure - See TireStatus + * @return {UnsubscribeVehicleDataResponse} + */ + setTirePressure (pressure) { + this.validateType(VehicleDataResult, pressure); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE, pressure); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getTirePressure () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE); + } + + /** + * @param {VehicleDataResult} odometer - Odometer in km + * @return {UnsubscribeVehicleDataResponse} + */ + setOdometer (odometer) { + this.validateType(VehicleDataResult, odometer); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ODOMETER, odometer); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getOdometer () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ODOMETER); + } + + /** + * @param {VehicleDataResult} status - The status of the seat belts + * @return {UnsubscribeVehicleDataResponse} + */ + setBeltStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_BELT_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getBeltStatus () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_BELT_STATUS); + } + + /** + * @param {VehicleDataResult} information - The body information including power modes + * @return {UnsubscribeVehicleDataResponse} + */ + setBodyInformation (information) { + this.validateType(VehicleDataResult, information); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION, information); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getBodyInformation () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION); + } + + /** + * @param {VehicleDataResult} status - The device status including signal and battery strength + * @return {UnsubscribeVehicleDataResponse} + */ + setDeviceStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getDeviceStatus () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS); + } + + /** + * @param {VehicleDataResult} braking - The status of the brake pedal + * @return {UnsubscribeVehicleDataResponse} + */ + setDriverBraking (braking) { + this.validateType(VehicleDataResult, braking); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING, braking); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getDriverBraking () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING); + } + + /** + * @param {VehicleDataResult} status - The status of the wipers + * @return {UnsubscribeVehicleDataResponse} + */ + setWiperStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getWiperStatus () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS); + } + + /** + * @param {VehicleDataResult} status - Status of the head lamps + * @return {UnsubscribeVehicleDataResponse} + */ + setHeadLampStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getHeadLampStatus () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS); + } + + /** + * @param {VehicleDataResult} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {UnsubscribeVehicleDataResponse} + */ + setEngineTorque (torque) { + this.validateType(VehicleDataResult, torque); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE, torque); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getEngineTorque () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE); + } + + /** + * @param {VehicleDataResult} position - Accelerator pedal position (percentage depressed) + * @return {UnsubscribeVehicleDataResponse} + */ + setAccPedalPosition (position) { + this.validateType(VehicleDataResult, position); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getAccPedalPosition () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION); + } + + /** + * @param {VehicleDataResult} angle - Current angle of the steering wheel (in deg) + * @return {UnsubscribeVehicleDataResponse} + */ + setSteeringWheelAngle (angle) { + this.validateType(VehicleDataResult, angle); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getSteeringWheelAngle () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE); + } + + /** + * @param {VehicleDataResult} life - The estimated percentage of remaining oil life of the engine. + * @return {UnsubscribeVehicleDataResponse} + */ + setEngineOilLife (life) { + this.validateType(VehicleDataResult, life); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getEngineOilLife () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE); + } + + /** + * @param {VehicleDataResult} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {UnsubscribeVehicleDataResponse} + */ + setElectronicParkBrakeStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getElectronicParkBrakeStatus () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + + /** + * @param {VehicleDataResult} id - Parameter used by cloud apps to identify a head unit + * @return {UnsubscribeVehicleDataResponse} + */ + setCloudAppVehicleID (id) { + this.validateType(VehicleDataResult, id); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getCloudAppVehicleID () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID); + } + + /** + * @param {VehicleDataResult} info - Emergency Call notification and confirmation data + * @return {UnsubscribeVehicleDataResponse} + */ + setECallInfo (info) { + this.validateType(VehicleDataResult, info); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO, info); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getECallInfo () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO); + } + + /** + * @param {VehicleDataResult} status - The status of the air bags + * @return {UnsubscribeVehicleDataResponse} + */ + setAirbagStatus (status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS, status); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getAirbagStatus () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS); + } + + /** + * @param {VehicleDataResult} event - Information related to an emergency event (and if it occurred) + * @return {UnsubscribeVehicleDataResponse} + */ + setEmergencyEvent (event) { + this.validateType(VehicleDataResult, event); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT, event); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getEmergencyEvent () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT); + } + + /** + * @param {VehicleDataResult} modes - The status modes of the cluster + * @return {UnsubscribeVehicleDataResponse} + */ + setClusterModes (modes) { + this.validateType(VehicleDataResult, modes); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES, modes); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getClusterModes () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES); + } + + /** + * @param {VehicleDataResult} key - Information related to the MyKey feature + * @return {UnsubscribeVehicleDataResponse} + */ + setMyKey (key) { + this.validateType(VehicleDataResult, key); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_MY_KEY, key); + return this; + } + + /** + * @return {VehicleDataResult} + */ + getMyKey () { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_MY_KEY); + } +} + +UnsubscribeVehicleDataResponse.KEY_GPS = 'gps'; +UnsubscribeVehicleDataResponse.KEY_SPEED = 'speed'; +UnsubscribeVehicleDataResponse.KEY_RPM = 'rpm'; +UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel'; +UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; +UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; +UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange'; +UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; +UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal'; +UnsubscribeVehicleDataResponse.KEY_PRNDL = 'prndl'; +UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure'; +UnsubscribeVehicleDataResponse.KEY_ODOMETER = 'odometer'; +UnsubscribeVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus'; +UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation'; +UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus'; +UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking'; +UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus'; +UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; +UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque'; +UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; +UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; +UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; +UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; +UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; +UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo'; +UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus'; +UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent'; +UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES = 'clusterModes'; +UnsubscribeVehicleDataResponse.KEY_MY_KEY = 'myKey'; + +export { UnsubscribeVehicleDataResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnsubscribeWayPoints.js b/lib/js/src/rpc/messages/UnsubscribeWayPoints.js new file mode 100644 index 00000000..919049c5 --- /dev/null +++ b/lib/js/src/rpc/messages/UnsubscribeWayPoints.js @@ -0,0 +1,51 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; + +/** + * Request to unsubscribe from WayPoints and Destination + */ +class UnsubscribeWayPoints extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeWayPoints); + } +} + + +export { UnsubscribeWayPoints }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UnsubscribeWayPointsResponse.js b/lib/js/src/rpc/messages/UnsubscribeWayPointsResponse.js new file mode 100644 index 00000000..72d0611a --- /dev/null +++ b/lib/js/src/rpc/messages/UnsubscribeWayPointsResponse.js @@ -0,0 +1,67 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { LocationDetails } from '../structs/LocationDetails.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class UnsubscribeWayPointsResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeWayPoints); + } + + /** + * @param {LocationDetails[]} points - See LocationDetails + * @return {UnsubscribeWayPointsResponse} + */ + setWayPoints (points) { + this.validateType(LocationDetails, points, true); + this.setParameter(UnsubscribeWayPointsResponse.KEY_WAY_POINTS, points); + return this; + } + + /** + * @return {LocationDetails[]} + */ + getWayPoints () { + return this.getObject(LocationDetails, UnsubscribeWayPointsResponse.KEY_WAY_POINTS); + } +} + +UnsubscribeWayPointsResponse.KEY_WAY_POINTS = 'wayPoints'; + +export { UnsubscribeWayPointsResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UpdateTurnList.js b/lib/js/src/rpc/messages/UpdateTurnList.js new file mode 100644 index 00000000..87daf9cc --- /dev/null +++ b/lib/js/src/rpc/messages/UpdateTurnList.js @@ -0,0 +1,86 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Turn } from '../structs/Turn.js'; +import { RpcRequest } from '../RpcRequest.js'; +import { FunctionID } from '../enums/FunctionID.js'; +import { SoftButton } from '../structs/SoftButton.js'; + +class UpdateTurnList extends RpcRequest { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UpdateTurnList); + } + + /** + * @param {Turn[]} list + * @return {UpdateTurnList} + */ + setTurnList (list) { + this.validateType(Turn, list, true); + this.setParameter(UpdateTurnList.KEY_TURN_LIST, list); + return this; + } + + /** + * @return {Turn[]} + */ + getTurnList () { + return this.getObject(Turn, UpdateTurnList.KEY_TURN_LIST); + } + + /** + * @param {SoftButton[]} buttons - If omitted on supported displays, app-defined SoftButton will be left blank. + * @return {UpdateTurnList} + */ + setSoftButtons (buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(UpdateTurnList.KEY_SOFT_BUTTONS, buttons); + return this; + } + + /** + * @return {SoftButton[]} + */ + getSoftButtons () { + return this.getObject(SoftButton, UpdateTurnList.KEY_SOFT_BUTTONS); + } +} + +UpdateTurnList.KEY_TURN_LIST = 'turnList'; +UpdateTurnList.KEY_SOFT_BUTTONS = 'softButtons'; + +export { UpdateTurnList }; \ No newline at end of file diff --git a/lib/js/src/rpc/messages/UpdateTurnListResponse.js b/lib/js/src/rpc/messages/UpdateTurnListResponse.js new file mode 100644 index 00000000..788902a6 --- /dev/null +++ b/lib/js/src/rpc/messages/UpdateTurnListResponse.js @@ -0,0 +1,48 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { FunctionID } from '../enums/FunctionID.js'; +import { RpcResponse } from '../RpcResponse.js'; + +class UpdateTurnListResponse extends RpcResponse { + /** + * @constructor + */ + constructor (store) { + super(store); + this.setFunctionName(FunctionID.UpdateTurnList); + } +} + + +export { UpdateTurnListResponse }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AirbagStatus.js b/lib/js/src/rpc/structs/AirbagStatus.js new file mode 100644 index 00000000..8f463b91 --- /dev/null +++ b/lib/js/src/rpc/structs/AirbagStatus.js @@ -0,0 +1,197 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js'; + +class AirbagStatus extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvBag_D_Ltchd". See VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setDriverAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvSideBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setDriverSideAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverSideAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvCrtnBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setDriverCurtainAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverCurtainAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasBag_D_Ltchd". See VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setPassengerAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getPassengerAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasCrtnBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setPassengerCurtainAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getPassengerCurtainAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsKneeDrvBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setDriverKneeAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverKneeAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasSideBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setPassengerSideAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getPassengerSideAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsKneePasBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + setPassengerKneeAirbagDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getPassengerKneeAirbagDeployed () { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED); + } +} + +AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED = 'driverAirbagDeployed'; +AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED = 'driverSideAirbagDeployed'; +AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED = 'driverCurtainAirbagDeployed'; +AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED = 'passengerAirbagDeployed'; +AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED = 'passengerCurtainAirbagDeployed'; +AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED = 'driverKneeAirbagDeployed'; +AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED = 'passengerSideAirbagDeployed'; +AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED = 'passengerKneeAirbagDeployed'; + +export { AirbagStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AppInfo.js b/lib/js/src/rpc/structs/AppInfo.js index c8745f29..6a3e25c3 100644 --- a/lib/js/src/rpc/structs/AppInfo.js +++ b/lib/js/src/rpc/structs/AppInfo.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,73 +33,80 @@ import { RpcStruct } from '../RpcStruct.js'; +/** + * Contains detailed information about the registered application. + */ class AppInfo extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {String} appDisplayName - * @return {AppInfo} - */ - setAppDisplayName (appDisplayName) { - this.setParameter(AppInfo.KEY_APP_DISPLAY_NAME, appDisplayName); + * @param {String} name - The name displayed for the mobile application on the mobile device (can differ from the + * app name set in the initial RAI request). + * @return {AppInfo} + */ + setAppDisplayName (name) { + this.setParameter(AppInfo.KEY_APP_DISPLAY_NAME, name); return this; } /** - * @return {String} - */ + * @return {String} + */ getAppDisplayName () { return this.getParameter(AppInfo.KEY_APP_DISPLAY_NAME); } - /** - * @param {String} appBundleID - * @return {AppInfo} - */ - setAppBundleID (appBundleID) { - this.setParameter(AppInfo.KEY_APP_BUNDLE_ID, appBundleID); + * @param {String} id - The AppBundleID of an iOS application or package name of the Android application. This + * supports App Launch strategies for each platform. + * @return {AppInfo} + */ + setAppBundleID (id) { + this.setParameter(AppInfo.KEY_APP_BUNDLE_ID, id); return this; } /** - * @return {String} - */ + * @return {String} + */ getAppBundleID () { return this.getParameter(AppInfo.KEY_APP_BUNDLE_ID); } - /** - * @param {String} appVersion - * @return {AppInfo} - */ - setAppVersion (appVersion) { - this.setParameter(AppInfo.KEY_APP_VERSION, appVersion); + * @param {String} version - Represents the build version number of this particular mobile app. + * @return {AppInfo} + */ + setAppVersion (version) { + this.setParameter(AppInfo.KEY_APP_VERSION, version); return this; } /** - * @return {String} - */ + * @return {String} + */ getAppVersion () { return this.getParameter(AppInfo.KEY_APP_VERSION); } /** - * @param {String} appIcon string of the app icon file name - * @return {AppInfo} - */ - setAppIcon (appIcon) { - this.setParameter(AppInfo.KEY_APP_ICON, appIcon); + * @param {String} icon - A file reference to the icon utilized by this app (simplifies the process of setting an + * app icon during app registration). + * @return {AppInfo} + */ + setAppIcon (icon) { + this.setParameter(AppInfo.KEY_APP_ICON, icon); return this; } /** - * @return {String} - */ + * @return {String} + */ getAppIcon () { return this.getParameter(AppInfo.KEY_APP_ICON); } @@ -109,4 +117,4 @@ AppInfo.KEY_APP_BUNDLE_ID = 'appBundleID'; AppInfo.KEY_APP_VERSION = 'appVersion'; AppInfo.KEY_APP_ICON = 'appIcon'; -export { AppInfo }; +export { AppInfo }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AppServiceCapability.js b/lib/js/src/rpc/structs/AppServiceCapability.js new file mode 100644 index 00000000..4201a6dd --- /dev/null +++ b/lib/js/src/rpc/structs/AppServiceCapability.js @@ -0,0 +1,85 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { ServiceUpdateReason } from '../enums/ServiceUpdateReason.js'; +import { AppServiceRecord } from './AppServiceRecord.js'; + +class AppServiceCapability extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {ServiceUpdateReason} reason - Only included in OnSystemCapabilityUpdated. Update reason for service + * record. + * @return {AppServiceCapability} + */ + setUpdateReason (reason) { + this.validateType(ServiceUpdateReason, reason); + this.setParameter(AppServiceCapability.KEY_UPDATE_REASON, reason); + return this; + } + + /** + * @return {ServiceUpdateReason} + */ + getUpdateReason () { + return this.getObject(ServiceUpdateReason, AppServiceCapability.KEY_UPDATE_REASON); + } + + /** + * @param {AppServiceRecord} record - Service record for a specific app service provider + * @return {AppServiceCapability} + */ + setUpdatedAppServiceRecord (record) { + this.validateType(AppServiceRecord, record); + this.setParameter(AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD, record); + return this; + } + + /** + * @return {AppServiceRecord} + */ + getUpdatedAppServiceRecord () { + return this.getObject(AppServiceRecord, AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD); + } +} + +AppServiceCapability.KEY_UPDATE_REASON = 'updateReason'; +AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD = 'updatedAppServiceRecord'; + +export { AppServiceCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AppServiceData.js b/lib/js/src/rpc/structs/AppServiceData.js new file mode 100644 index 00000000..3b9e9501 --- /dev/null +++ b/lib/js/src/rpc/structs/AppServiceData.js @@ -0,0 +1,143 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { NavigationServiceData } from './NavigationServiceData.js'; +import { MediaServiceData } from './MediaServiceData.js'; +import { WeatherServiceData } from './WeatherServiceData.js'; + +/** + * Contains all the current data of the app service. The serviceType will link to which of the service data objects are + * included in this object (e.g. if the service type is MEDIA, the mediaServiceData param should be included). + */ +class AppServiceData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum + * equivalent types. Parameter is a string to allow for new service types to be used by apps + * on older versions of SDL Core. + * @return {AppServiceData} + */ + setServiceType (type) { + this.setParameter(AppServiceData.KEY_SERVICE_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getServiceType () { + return this.getParameter(AppServiceData.KEY_SERVICE_TYPE); + } + + /** + * @param {String} id + * @return {AppServiceData} + */ + setServiceID (id) { + this.setParameter(AppServiceData.KEY_SERVICE_ID, id); + return this; + } + + /** + * @return {String} + */ + getServiceID () { + return this.getParameter(AppServiceData.KEY_SERVICE_ID); + } + + /** + * @param {MediaServiceData} data - This data is related to what a media service should provide + * @return {AppServiceData} + */ + setMediaServiceData (data) { + this.validateType(MediaServiceData, data); + this.setParameter(AppServiceData.KEY_MEDIA_SERVICE_DATA, data); + return this; + } + + /** + * @return {MediaServiceData} + */ + getMediaServiceData () { + return this.getObject(MediaServiceData, AppServiceData.KEY_MEDIA_SERVICE_DATA); + } + + /** + * @param {WeatherServiceData} data - This data is related to what a weather service would provide + * @return {AppServiceData} + */ + setWeatherServiceData (data) { + this.validateType(WeatherServiceData, data); + this.setParameter(AppServiceData.KEY_WEATHER_SERVICE_DATA, data); + return this; + } + + /** + * @return {WeatherServiceData} + */ + getWeatherServiceData () { + return this.getObject(WeatherServiceData, AppServiceData.KEY_WEATHER_SERVICE_DATA); + } + + /** + * @param {NavigationServiceData} data - This data is related to what a navigation service would provide. + * @return {AppServiceData} + */ + setNavigationServiceData (data) { + this.validateType(NavigationServiceData, data); + this.setParameter(AppServiceData.KEY_NAVIGATION_SERVICE_DATA, data); + return this; + } + + /** + * @return {NavigationServiceData} + */ + getNavigationServiceData () { + return this.getObject(NavigationServiceData, AppServiceData.KEY_NAVIGATION_SERVICE_DATA); + } +} + +AppServiceData.KEY_SERVICE_TYPE = 'serviceType'; +AppServiceData.KEY_SERVICE_ID = 'serviceID'; +AppServiceData.KEY_MEDIA_SERVICE_DATA = 'mediaServiceData'; +AppServiceData.KEY_WEATHER_SERVICE_DATA = 'weatherServiceData'; +AppServiceData.KEY_NAVIGATION_SERVICE_DATA = 'navigationServiceData'; + +export { AppServiceData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AppServiceManifest.js b/lib/js/src/rpc/structs/AppServiceManifest.js new file mode 100644 index 00000000..a89403f9 --- /dev/null +++ b/lib/js/src/rpc/structs/AppServiceManifest.js @@ -0,0 +1,220 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { NavigationServiceManifest } from './NavigationServiceManifest.js'; +import { Image } from './Image.js'; +import { SdlMsgVersion } from './SdlMsgVersion.js'; +import { WeatherServiceManifest } from './WeatherServiceManifest.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { MediaServiceManifest } from './MediaServiceManifest.js'; + +/** + * This manifest contains all the information necessary for the service to be published, activated, and consumers able + * to interact with it + */ +class AppServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - Unique name of this service + * @return {AppServiceManifest} + */ + setServiceName (name) { + this.setParameter(AppServiceManifest.KEY_SERVICE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getServiceName () { + return this.getParameter(AppServiceManifest.KEY_SERVICE_NAME); + } + + /** + * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum + * equivalent types. Parameter is a string to allow for new service types to be used by apps + * on older versions of SDL Core. + * @return {AppServiceManifest} + */ + setServiceType (type) { + this.setParameter(AppServiceManifest.KEY_SERVICE_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getServiceType () { + return this.getParameter(AppServiceManifest.KEY_SERVICE_TYPE); + } + + /** + * @param {Image} icon - The icon to be associated with this service. Most likely the same as the appIcon. + * @return {AppServiceManifest} + */ + setServiceIcon (icon) { + this.validateType(Image, icon); + this.setParameter(AppServiceManifest.KEY_SERVICE_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getServiceIcon () { + return this.getObject(Image, AppServiceManifest.KEY_SERVICE_ICON); + } + + /** + * @param {Boolean} consumers - If true, app service consumers beyond the IVI system will be able to access this + * service. If false, only the IVI system will be able consume the service. If not + * provided, it is assumed to be false. + * @return {AppServiceManifest} + */ + setAllowAppConsumers (consumers) { + this.setParameter(AppServiceManifest.KEY_ALLOW_APP_CONSUMERS, consumers); + return this; + } + + /** + * @return {Boolean} + */ + getAllowAppConsumers () { + return this.getParameter(AppServiceManifest.KEY_ALLOW_APP_CONSUMERS); + } + + /** + * @param {SdlMsgVersion} version - This is the max RPC Spec version the app service understands. This is important + * during the RPC passthrough functionality. If not included, it is assumed the max + * version of the module is acceptable. + * @return {AppServiceManifest} + */ + setRpcSpecVersion (version) { + this.validateType(SdlMsgVersion, version); + this.setParameter(AppServiceManifest.KEY_RPC_SPEC_VERSION, version); + return this; + } + + /** + * @return {SdlMsgVersion} + */ + getRpcSpecVersion () { + return this.getObject(SdlMsgVersion, AppServiceManifest.KEY_RPC_SPEC_VERSION); + } + + /** + * @param {Number[]} cs - This field contains the Function IDs for the RPCs that this service intends to handle + * correctly. This means the service will provide meaningful responses. + * @return {AppServiceManifest} + */ + setHandledRPCs (cs) { + this.setParameter(AppServiceManifest.KEY_HANDLED_RPCS, cs); + return this; + } + + /** + * @return {Number[]} + */ + getHandledRPCs () { + return this.getParameter(AppServiceManifest.KEY_HANDLED_RPCS); + } + + /** + * @param {MediaServiceManifest} manifest + * @return {AppServiceManifest} + */ + setMediaServiceManifest (manifest) { + this.validateType(MediaServiceManifest, manifest); + this.setParameter(AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST, manifest); + return this; + } + + /** + * @return {MediaServiceManifest} + */ + getMediaServiceManifest () { + return this.getObject(MediaServiceManifest, AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST); + } + + /** + * @param {WeatherServiceManifest} manifest + * @return {AppServiceManifest} + */ + setWeatherServiceManifest (manifest) { + this.validateType(WeatherServiceManifest, manifest); + this.setParameter(AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST, manifest); + return this; + } + + /** + * @return {WeatherServiceManifest} + */ + getWeatherServiceManifest () { + return this.getObject(WeatherServiceManifest, AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST); + } + + /** + * @param {NavigationServiceManifest} manifest + * @return {AppServiceManifest} + */ + setNavigationServiceManifest (manifest) { + this.validateType(NavigationServiceManifest, manifest); + this.setParameter(AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST, manifest); + return this; + } + + /** + * @return {NavigationServiceManifest} + */ + getNavigationServiceManifest () { + return this.getObject(NavigationServiceManifest, AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST); + } +} + +AppServiceManifest.KEY_SERVICE_NAME = 'serviceName'; +AppServiceManifest.KEY_SERVICE_TYPE = 'serviceType'; +AppServiceManifest.KEY_SERVICE_ICON = 'serviceIcon'; +AppServiceManifest.KEY_ALLOW_APP_CONSUMERS = 'allowAppConsumers'; +AppServiceManifest.KEY_RPC_SPEC_VERSION = 'rpcSpecVersion'; +AppServiceManifest.KEY_HANDLED_RPCS = 'handledRPCs'; +AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST = 'mediaServiceManifest'; +AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST = 'weatherServiceManifest'; +AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST = 'navigationServiceManifest'; + +export { AppServiceManifest }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AppServiceRecord.js b/lib/js/src/rpc/structs/AppServiceRecord.js new file mode 100644 index 00000000..c5a6b9a5 --- /dev/null +++ b/lib/js/src/rpc/structs/AppServiceRecord.js @@ -0,0 +1,125 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { AppServiceManifest } from './AppServiceManifest.js'; + +/** + * This is the record of an app service publisher that the module has. It should contain the most up to date + * information including the service's active state + */ +class AppServiceRecord extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} id - A unique ID tied to this specific service record. The ID is supplied by the module that + * services publish themselves. + * @return {AppServiceRecord} + */ + setServiceID (id) { + this.setParameter(AppServiceRecord.KEY_SERVICE_ID, id); + return this; + } + + /** + * @return {String} + */ + getServiceID () { + return this.getParameter(AppServiceRecord.KEY_SERVICE_ID); + } + + /** + * @param {AppServiceManifest} manifest - Manifest for the service that this record is for. + * @return {AppServiceRecord} + */ + setServiceManifest (manifest) { + this.validateType(AppServiceManifest, manifest); + this.setParameter(AppServiceRecord.KEY_SERVICE_MANIFEST, manifest); + return this; + } + + /** + * @return {AppServiceManifest} + */ + getServiceManifest () { + return this.getObject(AppServiceManifest, AppServiceRecord.KEY_SERVICE_MANIFEST); + } + + /** + * @param {Boolean} published - If true, the service is published and available. If false, the service has likely + * just been unpublished, and should be considered unavailable. + * @return {AppServiceRecord} + */ + setServicePublished (published) { + this.setParameter(AppServiceRecord.KEY_SERVICE_PUBLISHED, published); + return this; + } + + /** + * @return {Boolean} + */ + getServicePublished () { + return this.getParameter(AppServiceRecord.KEY_SERVICE_PUBLISHED); + } + + /** + * @param {Boolean} active - If true, the service is the active primary service of the supplied service type. It + * will receive all potential RPCs that are passed through to that service type. If false, + * it is not the primary service of the supplied type. See servicePublished for its + * availability. + * @return {AppServiceRecord} + */ + setServiceActive (active) { + this.setParameter(AppServiceRecord.KEY_SERVICE_ACTIVE, active); + return this; + } + + /** + * @return {Boolean} + */ + getServiceActive () { + return this.getParameter(AppServiceRecord.KEY_SERVICE_ACTIVE); + } +} + +AppServiceRecord.KEY_SERVICE_ID = 'serviceID'; +AppServiceRecord.KEY_SERVICE_MANIFEST = 'serviceManifest'; +AppServiceRecord.KEY_SERVICE_PUBLISHED = 'servicePublished'; +AppServiceRecord.KEY_SERVICE_ACTIVE = 'serviceActive'; + +export { AppServiceRecord }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AppServicesCapabilities.js b/lib/js/src/rpc/structs/AppServicesCapabilities.js new file mode 100644 index 00000000..74153e50 --- /dev/null +++ b/lib/js/src/rpc/structs/AppServicesCapabilities.js @@ -0,0 +1,70 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { AppServiceCapability } from './AppServiceCapability.js'; + +/** + * Capabilities of app services including what service types are supported and the current state of services. + */ +class AppServicesCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {AppServiceCapability[]} services - An array of currently available services. If this is an update to the + * capability the affected services will include an update reason in that + * item + * @return {AppServicesCapabilities} + */ + setAppServices (services) { + this.validateType(AppServiceCapability, services, true); + this.setParameter(AppServicesCapabilities.KEY_APP_SERVICES, services); + return this; + } + + /** + * @return {AppServiceCapability[]} + */ + getAppServices () { + return this.getObject(AppServiceCapability, AppServicesCapabilities.KEY_APP_SERVICES); + } +} + +AppServicesCapabilities.KEY_APP_SERVICES = 'appServices'; + +export { AppServicesCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AudioControlCapabilities.js b/lib/js/src/rpc/structs/AudioControlCapabilities.js new file mode 100644 index 00000000..ff71a361 --- /dev/null +++ b/lib/js/src/rpc/structs/AudioControlCapabilities.js @@ -0,0 +1,169 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { ModuleInfo } from './ModuleInfo.js'; + +class AudioControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - The short friendly name of the light control module. It should not be used to identify a + * module by mobile application. + * @return {AudioControlCapabilities} + */ + setModuleName (name) { + this.setParameter(AudioControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getModuleName () { + return this.getParameter(AudioControlCapabilities.KEY_MODULE_NAME); + } + + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {AudioControlCapabilities} + */ + setModuleInfo (info) { + this.validateType(ModuleInfo, info); + this.setParameter(AudioControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + + /** + * @return {ModuleInfo} + */ + getModuleInfo () { + return this.getObject(ModuleInfo, AudioControlCapabilities.KEY_MODULE_INFO); + } + + /** + * @param {Boolean} available - Availability of the control of audio source. + * @return {AudioControlCapabilities} + */ + setSourceAvailable (available) { + this.setParameter(AudioControlCapabilities.KEY_SOURCE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getSourceAvailable () { + return this.getParameter(AudioControlCapabilities.KEY_SOURCE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the keepContext parameter. + * @return {AudioControlCapabilities} + */ + setKeepContextAvailable (available) { + this.setParameter(AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getKeepContextAvailable () { + return this.getParameter(AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of audio volume. + * @return {AudioControlCapabilities} + */ + setVolumeAvailable (available) { + this.setParameter(AudioControlCapabilities.KEY_VOLUME_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getVolumeAvailable () { + return this.getParameter(AudioControlCapabilities.KEY_VOLUME_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of Equalizer Settings. + * @return {AudioControlCapabilities} + */ + setEqualizerAvailable (available) { + this.setParameter(AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getEqualizerAvailable () { + return this.getParameter(AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE); + } + + /** + * @param {Number} id - Must be included if equalizerAvailable=true, and assume all IDs starting from 1 to this + * value are valid + * @return {AudioControlCapabilities} + */ + setEqualizerMaxChannelId (id) { + this.setParameter(AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID, id); + return this; + } + + /** + * @return {Number} + */ + getEqualizerMaxChannelId () { + return this.getParameter(AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID); + } +} + +AudioControlCapabilities.KEY_MODULE_NAME = 'moduleName'; +AudioControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; +AudioControlCapabilities.KEY_SOURCE_AVAILABLE = 'sourceAvailable'; +AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE = 'keepContextAvailable'; +AudioControlCapabilities.KEY_VOLUME_AVAILABLE = 'volumeAvailable'; +AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE = 'equalizerAvailable'; +AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID = 'equalizerMaxChannelId'; + +export { AudioControlCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AudioControlData.js b/lib/js/src/rpc/structs/AudioControlData.js new file mode 100644 index 00000000..9fd6bf00 --- /dev/null +++ b/lib/js/src/rpc/structs/AudioControlData.js @@ -0,0 +1,127 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { PrimaryAudioSource } from '../enums/PrimaryAudioSource.js'; +import { EqualizerSettings } from './EqualizerSettings.js'; + +class AudioControlData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {PrimaryAudioSource} source - In a getter response or a notification, it is the current primary audio + * source of the system. In a setter request, it is the target audio source + * that the system shall switch to. If the value is MOBILE_APP, the system + * shall switch to the mobile media app that issues the setter RPC. + * @return {AudioControlData} + */ + setSource (source) { + this.validateType(PrimaryAudioSource, source); + this.setParameter(AudioControlData.KEY_SOURCE, source); + return this; + } + + /** + * @return {PrimaryAudioSource} + */ + getSource () { + return this.getObject(PrimaryAudioSource, AudioControlData.KEY_SOURCE); + } + + /** + * @param {Boolean} context - This parameter shall not be present in any getter responses or notifications. This + * parameter is optional in a setter request. The default value is false if it is not + * included. If it is false, the system not only changes the audio source but also brings + * the default application or system UI associated with the audio source to foreground. + * If it is true, the system only changes the audio source, but keeps the current + * application in foreground. + * @return {AudioControlData} + */ + setKeepContext (context) { + this.setParameter(AudioControlData.KEY_KEEP_CONTEXT, context); + return this; + } + + /** + * @return {Boolean} + */ + getKeepContext () { + return this.getParameter(AudioControlData.KEY_KEEP_CONTEXT); + } + + /** + * @param {Number} volume - Reflects the volume of audio, from 0%-100%. + * @return {AudioControlData} + */ + setVolume (volume) { + this.setParameter(AudioControlData.KEY_VOLUME, volume); + return this; + } + + /** + * @return {Number} + */ + getVolume () { + return this.getParameter(AudioControlData.KEY_VOLUME); + } + + /** + * @param {EqualizerSettings[]} settings - Defines the list of supported channels (band) and their current/desired + * settings on HMI + * @return {AudioControlData} + */ + setEqualizerSettings (settings) { + this.validateType(EqualizerSettings, settings, true); + this.setParameter(AudioControlData.KEY_EQUALIZER_SETTINGS, settings); + return this; + } + + /** + * @return {EqualizerSettings[]} + */ + getEqualizerSettings () { + return this.getObject(EqualizerSettings, AudioControlData.KEY_EQUALIZER_SETTINGS); + } +} + +AudioControlData.KEY_SOURCE = 'source'; +AudioControlData.KEY_KEEP_CONTEXT = 'keepContext'; +AudioControlData.KEY_VOLUME = 'volume'; +AudioControlData.KEY_EQUALIZER_SETTINGS = 'equalizerSettings'; + +export { AudioControlData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/AudioPassThruCapabilities.js b/lib/js/src/rpc/structs/AudioPassThruCapabilities.js index f5ec65f6..8ea9c8b4 100644 --- a/lib/js/src/rpc/structs/AudioPassThruCapabilities.js +++ b/lib/js/src/rpc/structs/AudioPassThruCapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -35,61 +36,65 @@ import { SamplingRate } from '../enums/SamplingRate.js'; import { BitsPerSample } from '../enums/BitsPerSample.js'; import { AudioType } from '../enums/AudioType.js'; +/** + * Describes different audio type configurations for PerformAudioPassThru. e.g. {8kHz,8-bit,PCM} The audio is recorded + * in monaural. + */ class AudioPassThruCapabilities extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {SamplingRate} samplingRate - * @return {AudioPassThruCapabilities} - */ - setSamplingRate (samplingRate) { - this.validateType(SamplingRate, samplingRate); - - this.setParameter(AudioPassThruCapabilities.KEY_SAMPLING_RATE, samplingRate); + * @param {SamplingRate} rate - Describes different sampling options for PerformAudioPassThru. + * @return {AudioPassThruCapabilities} + */ + setSamplingRate (rate) { + this.validateType(SamplingRate, rate); + this.setParameter(AudioPassThruCapabilities.KEY_SAMPLING_RATE, rate); return this; } /** - * @return {SamplingRate} - */ + * @return {SamplingRate} + */ getSamplingRate () { return this.getObject(SamplingRate, AudioPassThruCapabilities.KEY_SAMPLING_RATE); } /** - * @param {BitsPerSample} bitsPerSample - * @return {AudioPassThruCapabilities} - */ - setBitsPerSample (bitsPerSample) { - this.validateType(BitsPerSample, bitsPerSample); - - this.setParameter(AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE, bitsPerSample); + * @param {BitsPerSample} sample - Describes different quality options for PerformAudioPassThru. + * @return {AudioPassThruCapabilities} + */ + setBitsPerSample (sample) { + this.validateType(BitsPerSample, sample); + this.setParameter(AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE, sample); return this; } /** - * @return {BitsPerSample} - */ + * @return {BitsPerSample} + */ getBitsPerSample () { return this.getObject(BitsPerSample, AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE); } /** - * @param {AudioType} bitsPerSample - * @return {AudioPassThruCapabilities} - */ - setAudioType (audioType) { - this.validateType(AudioType, audioType); - - this.setParameter(AudioPassThruCapabilities.KEY_AUDIO_TYPE, audioType); + * @param {AudioType} type - Describes different audio type options for PerformAudioPassThru. + * @return {AudioPassThruCapabilities} + */ + setAudioType (type) { + this.validateType(AudioType, type); + this.setParameter(AudioPassThruCapabilities.KEY_AUDIO_TYPE, type); return this; } /** - * @return {AudioType} - */ + * @return {AudioType} + */ getAudioType () { return this.getObject(AudioType, AudioPassThruCapabilities.KEY_AUDIO_TYPE); } @@ -99,4 +104,4 @@ AudioPassThruCapabilities.KEY_SAMPLING_RATE = 'samplingRate'; AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE = 'bitsPerSample'; AudioPassThruCapabilities.KEY_AUDIO_TYPE = 'audioType'; -export { AudioPassThruCapabilities }; +export { AudioPassThruCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/BeltStatus.js b/lib/js/src/rpc/structs/BeltStatus.js new file mode 100644 index 00000000..d499ae9e --- /dev/null +++ b/lib/js/src/rpc/structs/BeltStatus.js @@ -0,0 +1,318 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js'; + +class BeltStatus extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvBelt_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setDriverBeltDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(BeltStatus.KEY_DRIVER_BELT_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverBeltDeployed () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_DRIVER_BELT_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasBelt_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setPassengerBeltDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(BeltStatus.KEY_PASSENGER_BELT_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getPassengerBeltDeployed () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_BELT_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw1PasBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setPassengerBuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_PASSENGER_BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getPassengerBuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw1DrvBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setDriverBuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_DRIVER_BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getDriverBuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_DRIVER_BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2lBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setLeftRow2BuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getLeftRow2BuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} detected - References signal "VedsRw1PasChld_D_Ltchd". See + * VehicleDataEventStatus. + * @return {BeltStatus} + */ + setPassengerChildDetected (detected) { + this.validateType(VehicleDataEventStatus, detected); + this.setParameter(BeltStatus.KEY_PASSENGER_CHILD_DETECTED, detected); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getPassengerChildDetected () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_CHILD_DETECTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2rBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setRightRow2BuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getRightRow2BuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2mBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setMiddleRow2BuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getMiddleRow2BuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw3mBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setMiddleRow3BuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getMiddleRow3BuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw3lBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setLeftRow3BuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getLeftRow3BuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw3rBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setRightRow3BuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getRightRow3BuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2lRib_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setLeftRearInflatableBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getLeftRearInflatableBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2rRib_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setRightRearInflatableBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getRightRearInflatableBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED); + } + + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsRw1mBelt_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setMiddleRow1BeltDeployed (deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED, deployed); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getMiddleRow1BeltDeployed () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED); + } + + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw1mBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + setMiddleRow1BuckleBelted (belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED, belted); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getMiddleRow1BuckleBelted () { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED); + } +} + +BeltStatus.KEY_DRIVER_BELT_DEPLOYED = 'driverBeltDeployed'; +BeltStatus.KEY_PASSENGER_BELT_DEPLOYED = 'passengerBeltDeployed'; +BeltStatus.KEY_PASSENGER_BUCKLE_BELTED = 'passengerBuckleBelted'; +BeltStatus.KEY_DRIVER_BUCKLE_BELTED = 'driverBuckleBelted'; +BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED = 'leftRow2BuckleBelted'; +BeltStatus.KEY_PASSENGER_CHILD_DETECTED = 'passengerChildDetected'; +BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED = 'rightRow2BuckleBelted'; +BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED = 'middleRow2BuckleBelted'; +BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED = 'middleRow3BuckleBelted'; +BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED = 'leftRow3BuckleBelted'; +BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED = 'rightRow3BuckleBelted'; +BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED = 'leftRearInflatableBelted'; +BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED = 'rightRearInflatableBelted'; +BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED = 'middleRow1BeltDeployed'; +BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED = 'middleRow1BuckleBelted'; + +export { BeltStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/BodyInformation.js b/lib/js/src/rpc/structs/BodyInformation.js new file mode 100644 index 00000000..ebd0843f --- /dev/null +++ b/lib/js/src/rpc/structs/BodyInformation.js @@ -0,0 +1,169 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { IgnitionStatus } from '../enums/IgnitionStatus.js'; +import { IgnitionStableStatus } from '../enums/IgnitionStableStatus.js'; + +class BodyInformation extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} active - References signal "PrkBrkActv_B_Actl". + * @return {BodyInformation} + */ + setParkBrakeActive (active) { + this.setParameter(BodyInformation.KEY_PARK_BRAKE_ACTIVE, active); + return this; + } + + /** + * @return {Boolean} + */ + getParkBrakeActive () { + return this.getParameter(BodyInformation.KEY_PARK_BRAKE_ACTIVE); + } + + /** + * @param {IgnitionStableStatus} status - References signal "Ignition_Switch_Stable". See IgnitionStableStatus. + * @return {BodyInformation} + */ + setIgnitionStableStatus (status) { + this.validateType(IgnitionStableStatus, status); + this.setParameter(BodyInformation.KEY_IGNITION_STABLE_STATUS, status); + return this; + } + + /** + * @return {IgnitionStableStatus} + */ + getIgnitionStableStatus () { + return this.getObject(IgnitionStableStatus, BodyInformation.KEY_IGNITION_STABLE_STATUS); + } + + /** + * @param {IgnitionStatus} status - References signal "Ignition_status". See IgnitionStatus. + * @return {BodyInformation} + */ + setIgnitionStatus (status) { + this.validateType(IgnitionStatus, status); + this.setParameter(BodyInformation.KEY_IGNITION_STATUS, status); + return this; + } + + /** + * @return {IgnitionStatus} + */ + getIgnitionStatus () { + return this.getObject(IgnitionStatus, BodyInformation.KEY_IGNITION_STATUS); + } + + /** + * @param {Boolean} ajar - References signal "DrStatDrv_B_Actl". + * @return {BodyInformation} + */ + setDriverDoorAjar (ajar) { + this.setParameter(BodyInformation.KEY_DRIVER_DOOR_AJAR, ajar); + return this; + } + + /** + * @return {Boolean} + */ + getDriverDoorAjar () { + return this.getParameter(BodyInformation.KEY_DRIVER_DOOR_AJAR); + } + + /** + * @param {Boolean} ajar - References signal "DrStatPsngr_B_Actl". + * @return {BodyInformation} + */ + setPassengerDoorAjar (ajar) { + this.setParameter(BodyInformation.KEY_PASSENGER_DOOR_AJAR, ajar); + return this; + } + + /** + * @return {Boolean} + */ + getPassengerDoorAjar () { + return this.getParameter(BodyInformation.KEY_PASSENGER_DOOR_AJAR); + } + + /** + * @param {Boolean} ajar - References signal "DrStatRl_B_Actl". + * @return {BodyInformation} + */ + setRearLeftDoorAjar (ajar) { + this.setParameter(BodyInformation.KEY_REAR_LEFT_DOOR_AJAR, ajar); + return this; + } + + /** + * @return {Boolean} + */ + getRearLeftDoorAjar () { + return this.getParameter(BodyInformation.KEY_REAR_LEFT_DOOR_AJAR); + } + + /** + * @param {Boolean} ajar - References signal "DrStatRr_B_Actl". + * @return {BodyInformation} + */ + setRearRightDoorAjar (ajar) { + this.setParameter(BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR, ajar); + return this; + } + + /** + * @return {Boolean} + */ + getRearRightDoorAjar () { + return this.getParameter(BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR); + } +} + +BodyInformation.KEY_PARK_BRAKE_ACTIVE = 'parkBrakeActive'; +BodyInformation.KEY_IGNITION_STABLE_STATUS = 'ignitionStableStatus'; +BodyInformation.KEY_IGNITION_STATUS = 'ignitionStatus'; +BodyInformation.KEY_DRIVER_DOOR_AJAR = 'driverDoorAjar'; +BodyInformation.KEY_PASSENGER_DOOR_AJAR = 'passengerDoorAjar'; +BodyInformation.KEY_REAR_LEFT_DOOR_AJAR = 'rearLeftDoorAjar'; +BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR = 'rearRightDoorAjar'; + +export { BodyInformation }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ButtonCapabilities.js b/lib/js/src/rpc/structs/ButtonCapabilities.js index ed7f742b..9be31b7f 100644 --- a/lib/js/src/rpc/structs/ButtonCapabilities.js +++ b/lib/js/src/rpc/structs/ButtonCapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -31,94 +32,102 @@ */ import { RpcStruct } from '../RpcStruct.js'; -import { ModuleInfo } from './ModuleInfo'; import { ButtonName } from '../enums/ButtonName.js'; +import { ModuleInfo } from './ModuleInfo.js'; +/** + * Contains information about a button's capabilities. + */ class ButtonCapabilities extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {ButtonName} name - * @return {ButtonCapabilities} - */ + * @param {ButtonName} name - The name of the button. See ButtonName. + * @return {ButtonCapabilities} + */ setName (name) { this.validateType(ButtonName, name); - this.setParameter(ButtonCapabilities.KEY_NAME, name); return this; } /** - * @return {ButtonName} - */ + * @return {ButtonName} + */ getName () { return this.getObject(ButtonName, ButtonCapabilities.KEY_NAME); } /** - * @param {ModuleInfo} moduleInfo - * @return {ButtonCapabilities} - */ - setModuleInfo (moduleInfo) { - this.validateType(ModuleInfo, moduleInfo); - - this.setParameter(ButtonCapabilities.KEY_MODULE_INFO, moduleInfo); + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {ButtonCapabilities} + */ + setModuleInfo (info) { + this.validateType(ModuleInfo, info); + this.setParameter(ButtonCapabilities.KEY_MODULE_INFO, info); return this; } /** - * @return {ModuleInfo} - */ + * @return {ModuleInfo} + */ getModuleInfo () { return this.getObject(ModuleInfo, ButtonCapabilities.KEY_MODULE_INFO); } /** - * @param {Boolean} shortPressAvailable - * @return {ButtonCapabilities} - */ - setShortPressAvailable (shortPressAvailable) { - this.setParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, shortPressAvailable); + * @param {Boolean} available - The button supports a short press. Whenever the button is pressed short, + * onButtonPressed( SHORT) will be invoked. + * @return {ButtonCapabilities} + */ + setShortPressAvailable (available) { + this.setParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getShortPressAvailable () { return this.getParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE); } /** - * @param {Boolean} longPressAvailable - * @return {ButtonCapabilities} - */ - setLongPressAvailable (longPressAvailable) { - this.setParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, longPressAvailable); + * @param {Boolean} available - The button supports a LONG press. Whenever the button is pressed long, + * onButtonPressed( LONG) will be invoked. + * @return {ButtonCapabilities} + */ + setLongPressAvailable (available) { + this.setParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getLongPressAvailable () { return this.getParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE); } /** - * @param {Boolean} upDownAvailable - * @return {ButtonCapabilities} - */ - setUpDownAvailable (upDownAvailable) { - this.setParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE, upDownAvailable); + * @param {Boolean} available - The button supports "button down" and "button up". Whenever the button is pressed, + * onButtonEvent( DOWN) will be invoked. Whenever the button is released, + * onButtonEvent( UP) will be invoked. + * @return {ButtonCapabilities} + */ + setUpDownAvailable (available) { + this.setParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getUpDownAvailable () { return this.getParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE); } @@ -130,4 +139,4 @@ ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable'; ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable'; ButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable'; -export { ButtonCapabilities }; +export { ButtonCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/Choice.js b/lib/js/src/rpc/structs/Choice.js new file mode 100644 index 00000000..a9e31bc7 --- /dev/null +++ b/lib/js/src/rpc/structs/Choice.js @@ -0,0 +1,171 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { Image } from './Image.js'; + +/** + * A choice is an option given to the user, which can be selected either by menu, or through voice recognition system. + */ +class Choice extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} id + * @return {Choice} + */ + setChoiceID (id) { + this.setParameter(Choice.KEY_CHOICE_ID, id); + return this; + } + + /** + * @return {Number} + */ + getChoiceID () { + return this.getParameter(Choice.KEY_CHOICE_ID); + } + + /** + * @param {String} name + * @return {Choice} + */ + setMenuName (name) { + this.setParameter(Choice.KEY_MENU_NAME, name); + return this; + } + + /** + * @return {String} + */ + getMenuName () { + return this.getParameter(Choice.KEY_MENU_NAME); + } + + /** + * @param {String[]} commands + * @return {Choice} + */ + setVrCommands (commands) { + this.setParameter(Choice.KEY_VR_COMMANDS, commands); + return this; + } + + /** + * @return {String[]} + */ + getVrCommands () { + return this.getParameter(Choice.KEY_VR_COMMANDS); + } + + /** + * @param {Image} image + * @return {Choice} + */ + setImage (image) { + this.validateType(Image, image); + this.setParameter(Choice.KEY_IMAGE, image); + return this; + } + + /** + * @return {Image} + */ + getImage () { + return this.getObject(Image, Choice.KEY_IMAGE); + } + + /** + * @param {String} text - Optional secondary text to display; e.g. address of POI in a search result entry + * @return {Choice} + */ + setSecondaryText (text) { + this.setParameter(Choice.KEY_SECONDARY_TEXT, text); + return this; + } + + /** + * @return {String} + */ + getSecondaryText () { + return this.getParameter(Choice.KEY_SECONDARY_TEXT); + } + + /** + * @param {String} text - Optional tertiary text to display; e.g. distance to POI for a search result entry + * @return {Choice} + */ + setTertiaryText (text) { + this.setParameter(Choice.KEY_TERTIARY_TEXT, text); + return this; + } + + /** + * @return {String} + */ + getTertiaryText () { + return this.getParameter(Choice.KEY_TERTIARY_TEXT); + } + + /** + * @param {Image} image - Optional secondary image struct for choice + * @return {Choice} + */ + setSecondaryImage (image) { + this.validateType(Image, image); + this.setParameter(Choice.KEY_SECONDARY_IMAGE, image); + return this; + } + + /** + * @return {Image} + */ + getSecondaryImage () { + return this.getObject(Image, Choice.KEY_SECONDARY_IMAGE); + } +} + +Choice.KEY_CHOICE_ID = 'choiceID'; +Choice.KEY_MENU_NAME = 'menuName'; +Choice.KEY_VR_COMMANDS = 'vrCommands'; +Choice.KEY_IMAGE = 'image'; +Choice.KEY_SECONDARY_TEXT = 'secondaryText'; +Choice.KEY_TERTIARY_TEXT = 'tertiaryText'; +Choice.KEY_SECONDARY_IMAGE = 'secondaryImage'; + +export { Choice }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ClimateControlCapabilities.js b/lib/js/src/rpc/structs/ClimateControlCapabilities.js new file mode 100644 index 00000000..360c27a9 --- /dev/null +++ b/lib/js/src/rpc/structs/ClimateControlCapabilities.js @@ -0,0 +1,394 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { DefrostZone } from '../enums/DefrostZone.js'; +import { VentilationMode } from '../enums/VentilationMode.js'; +import { ModuleInfo } from './ModuleInfo.js'; + +/** + * Contains information about a climate control module's capabilities. + */ +class ClimateControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - The short friendly name of the climate control module. It should not be used to identify a + * module by mobile application. + * @return {ClimateControlCapabilities} + */ + setModuleName (name) { + this.setParameter(ClimateControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getModuleName () { + return this.getParameter(ClimateControlCapabilities.KEY_MODULE_NAME); + } + + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {ClimateControlCapabilities} + */ + setModuleInfo (info) { + this.validateType(ModuleInfo, info); + this.setParameter(ClimateControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + + /** + * @return {ModuleInfo} + */ + getModuleInfo () { + return this.getObject(ModuleInfo, ClimateControlCapabilities.KEY_MODULE_INFO); + } + + /** + * @param {Boolean} available - Availability of the reading of current temperature. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setCurrentTemperatureAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getCurrentTemperatureAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of fan speed. True: Available, False: Not Available, Not + * present: Not Available. + * @return {ClimateControlCapabilities} + */ + setFanSpeedAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getFanSpeedAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of desired temperature. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setDesiredTemperatureAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getDesiredTemperatureAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of turn on/off AC. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setAcEnableAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getAcEnableAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of enable/disable air conditioning is ON on the maximum + * level. True: Available, False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setAcMaxEnableAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getAcMaxEnableAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of enable/disable circulate Air mode. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setCirculateAirEnableAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getCirculateAirEnableAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of enable/disable auto mode. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setAutoModeEnableAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getAutoModeEnableAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of enable/disable dual mode. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setDualModeEnableAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getDualModeEnableAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of defrost zones. True: Available, False: Not Available, + * Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setDefrostZoneAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getDefrostZoneAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE); + } + + /** + * @param {DefrostZone[]} zone - A set of all defrost zones that are controllable. + * @return {ClimateControlCapabilities} + */ + setDefrostZone (zone) { + this.validateType(DefrostZone, zone, true); + this.setParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE, zone); + return this; + } + + /** + * @return {DefrostZone[]} + */ + getDefrostZone () { + return this.getObject(DefrostZone, ClimateControlCapabilities.KEY_DEFROST_ZONE); + } + + /** + * @param {Boolean} available - Availability of the control of air ventilation mode. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setVentilationModeAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getVentilationModeAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE); + } + + /** + * @param {VentilationMode[]} mode - A set of all ventilation modes that are controllable. + * @return {ClimateControlCapabilities} + */ + setVentilationMode (mode) { + this.validateType(VentilationMode, mode, true); + this.setParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE, mode); + return this; + } + + /** + * @return {VentilationMode[]} + */ + getVentilationMode () { + return this.getObject(VentilationMode, ClimateControlCapabilities.KEY_VENTILATION_MODE); + } + + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Steering Wheel. True: + * Available, False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setHeatedSteeringWheelAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedSteeringWheelAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Windshield. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setHeatedWindshieldAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedWindshieldAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Rear Window. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setHeatedRearWindowAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedRearWindowAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Mirrors. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setHeatedMirrorsAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedMirrorsAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of enable/disable climate control. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + setClimateEnableAvailable (available) { + this.setParameter(ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getClimateEnableAvailable () { + return this.getParameter(ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE); + } +} + +ClimateControlCapabilities.KEY_MODULE_NAME = 'moduleName'; +ClimateControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; +ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE = 'currentTemperatureAvailable'; +ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE = 'fanSpeedAvailable'; +ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE = 'desiredTemperatureAvailable'; +ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE = 'acEnableAvailable'; +ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE = 'acMaxEnableAvailable'; +ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE = 'circulateAirEnableAvailable'; +ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE = 'autoModeEnableAvailable'; +ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE = 'dualModeEnableAvailable'; +ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE = 'defrostZoneAvailable'; +ClimateControlCapabilities.KEY_DEFROST_ZONE = 'defrostZone'; +ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE = 'ventilationModeAvailable'; +ClimateControlCapabilities.KEY_VENTILATION_MODE = 'ventilationMode'; +ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE = 'heatedSteeringWheelAvailable'; +ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE = 'heatedWindshieldAvailable'; +ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE = 'heatedRearWindowAvailable'; +ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE = 'heatedMirrorsAvailable'; +ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE = 'climateEnableAvailable'; + +export { ClimateControlCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ClimateControlData.js b/lib/js/src/rpc/structs/ClimateControlData.js new file mode 100644 index 00000000..2fa8062a --- /dev/null +++ b/lib/js/src/rpc/structs/ClimateControlData.js @@ -0,0 +1,308 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Temperature } from './Temperature.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { VentilationMode } from '../enums/VentilationMode.js'; +import { DefrostZone } from '../enums/DefrostZone.js'; + +class ClimateControlData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} speed + * @return {ClimateControlData} + */ + setFanSpeed (speed) { + this.setParameter(ClimateControlData.KEY_FAN_SPEED, speed); + return this; + } + + /** + * @return {Number} + */ + getFanSpeed () { + return this.getParameter(ClimateControlData.KEY_FAN_SPEED); + } + + /** + * @param {Temperature} temperature + * @return {ClimateControlData} + */ + setCurrentTemperature (temperature) { + this.validateType(Temperature, temperature); + this.setParameter(ClimateControlData.KEY_CURRENT_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Temperature} + */ + getCurrentTemperature () { + return this.getObject(Temperature, ClimateControlData.KEY_CURRENT_TEMPERATURE); + } + + /** + * @param {Temperature} temperature + * @return {ClimateControlData} + */ + setDesiredTemperature (temperature) { + this.validateType(Temperature, temperature); + this.setParameter(ClimateControlData.KEY_DESIRED_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Temperature} + */ + getDesiredTemperature () { + return this.getObject(Temperature, ClimateControlData.KEY_DESIRED_TEMPERATURE); + } + + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + setAcEnable (enable) { + this.setParameter(ClimateControlData.KEY_AC_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getAcEnable () { + return this.getParameter(ClimateControlData.KEY_AC_ENABLE); + } + + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + setCirculateAirEnable (enable) { + this.setParameter(ClimateControlData.KEY_CIRCULATE_AIR_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getCirculateAirEnable () { + return this.getParameter(ClimateControlData.KEY_CIRCULATE_AIR_ENABLE); + } + + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + setAutoModeEnable (enable) { + this.setParameter(ClimateControlData.KEY_AUTO_MODE_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getAutoModeEnable () { + return this.getParameter(ClimateControlData.KEY_AUTO_MODE_ENABLE); + } + + /** + * @param {DefrostZone} zone + * @return {ClimateControlData} + */ + setDefrostZone (zone) { + this.validateType(DefrostZone, zone); + this.setParameter(ClimateControlData.KEY_DEFROST_ZONE, zone); + return this; + } + + /** + * @return {DefrostZone} + */ + getDefrostZone () { + return this.getObject(DefrostZone, ClimateControlData.KEY_DEFROST_ZONE); + } + + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + setDualModeEnable (enable) { + this.setParameter(ClimateControlData.KEY_DUAL_MODE_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getDualModeEnable () { + return this.getParameter(ClimateControlData.KEY_DUAL_MODE_ENABLE); + } + + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + setAcMaxEnable (enable) { + this.setParameter(ClimateControlData.KEY_AC_MAX_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getAcMaxEnable () { + return this.getParameter(ClimateControlData.KEY_AC_MAX_ENABLE); + } + + /** + * @param {VentilationMode} mode + * @return {ClimateControlData} + */ + setVentilationMode (mode) { + this.validateType(VentilationMode, mode); + this.setParameter(ClimateControlData.KEY_VENTILATION_MODE, mode); + return this; + } + + /** + * @return {VentilationMode} + */ + getVentilationMode () { + return this.getObject(VentilationMode, ClimateControlData.KEY_VENTILATION_MODE); + } + + /** + * @param {Boolean} enable - value false means disabled/turn off, value true means enabled/turn on. + * @return {ClimateControlData} + */ + setHeatedSteeringWheelEnable (enable) { + this.setParameter(ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedSteeringWheelEnable () { + return this.getParameter(ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE); + } + + /** + * @param {Boolean} enable - value false means disabled, value true means enabled. + * @return {ClimateControlData} + */ + setHeatedWindshieldEnable (enable) { + this.setParameter(ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedWindshieldEnable () { + return this.getParameter(ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE); + } + + /** + * @param {Boolean} enable - value false means disabled, value true means enabled. + * @return {ClimateControlData} + */ + setHeatedRearWindowEnable (enable) { + this.setParameter(ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedRearWindowEnable () { + return this.getParameter(ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE); + } + + /** + * @param {Boolean} enable - value false means disabled, value true means enabled. + * @return {ClimateControlData} + */ + setHeatedMirrorsEnable (enable) { + this.setParameter(ClimateControlData.KEY_HEATED_MIRRORS_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getHeatedMirrorsEnable () { + return this.getParameter(ClimateControlData.KEY_HEATED_MIRRORS_ENABLE); + } + + /** + * @param {Boolean} enable - True if the climate module is on, false if the climate module is off + * @return {ClimateControlData} + */ + setClimateEnable (enable) { + this.setParameter(ClimateControlData.KEY_CLIMATE_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getClimateEnable () { + return this.getParameter(ClimateControlData.KEY_CLIMATE_ENABLE); + } +} + +ClimateControlData.KEY_FAN_SPEED = 'fanSpeed'; +ClimateControlData.KEY_CURRENT_TEMPERATURE = 'currentTemperature'; +ClimateControlData.KEY_DESIRED_TEMPERATURE = 'desiredTemperature'; +ClimateControlData.KEY_AC_ENABLE = 'acEnable'; +ClimateControlData.KEY_CIRCULATE_AIR_ENABLE = 'circulateAirEnable'; +ClimateControlData.KEY_AUTO_MODE_ENABLE = 'autoModeEnable'; +ClimateControlData.KEY_DEFROST_ZONE = 'defrostZone'; +ClimateControlData.KEY_DUAL_MODE_ENABLE = 'dualModeEnable'; +ClimateControlData.KEY_AC_MAX_ENABLE = 'acMaxEnable'; +ClimateControlData.KEY_VENTILATION_MODE = 'ventilationMode'; +ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE = 'heatedSteeringWheelEnable'; +ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE = 'heatedWindshieldEnable'; +ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE = 'heatedRearWindowEnable'; +ClimateControlData.KEY_HEATED_MIRRORS_ENABLE = 'heatedMirrorsEnable'; +ClimateControlData.KEY_CLIMATE_ENABLE = 'climateEnable'; + +export { ClimateControlData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/CloudAppProperties.js b/lib/js/src/rpc/structs/CloudAppProperties.js new file mode 100644 index 00000000..f093b37d --- /dev/null +++ b/lib/js/src/rpc/structs/CloudAppProperties.js @@ -0,0 +1,170 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { HybridAppPreference } from '../enums/HybridAppPreference.js'; + +class CloudAppProperties extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String[]} nicknames - An array of app names a cloud app is allowed to register with. If included in a + * SetCloudAppProperties request, this value will overwrite the existing "nicknames" + * field in the app policies section of the policy table. + * @return {CloudAppProperties} + */ + setNicknames (nicknames) { + this.setParameter(CloudAppProperties.KEY_NICKNAMES, nicknames); + return this; + } + + /** + * @return {String[]} + */ + getNicknames () { + return this.getParameter(CloudAppProperties.KEY_NICKNAMES); + } + + /** + * @param {String} id + * @return {CloudAppProperties} + */ + setAppID (id) { + this.setParameter(CloudAppProperties.KEY_APP_ID, id); + return this; + } + + /** + * @return {String} + */ + getAppID () { + return this.getParameter(CloudAppProperties.KEY_APP_ID); + } + + /** + * @param {Boolean} enabled - If true, cloud app will be included in HMI RPC UpdateAppList + * @return {CloudAppProperties} + */ + setEnabled (enabled) { + this.setParameter(CloudAppProperties.KEY_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getEnabled () { + return this.getParameter(CloudAppProperties.KEY_ENABLED); + } + + /** + * @param {String} token - Used to authenticate websocket connection on app activation + * @return {CloudAppProperties} + */ + setAuthToken (token) { + this.setParameter(CloudAppProperties.KEY_AUTH_TOKEN, token); + return this; + } + + /** + * @return {String} + */ + getAuthToken () { + return this.getParameter(CloudAppProperties.KEY_AUTH_TOKEN); + } + + /** + * @param {String} type - Specifies the connection type Core should use + * @return {CloudAppProperties} + */ + setCloudTransportType (type) { + this.setParameter(CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getCloudTransportType () { + return this.getParameter(CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE); + } + + /** + * @param {HybridAppPreference} preference - Specifies the user preference to use the cloud app version or mobile + * app version when both are available + * @return {CloudAppProperties} + */ + setHybridAppPreference (preference) { + this.validateType(HybridAppPreference, preference); + this.setParameter(CloudAppProperties.KEY_HYBRID_APP_PREFERENCE, preference); + return this; + } + + /** + * @return {HybridAppPreference} + */ + getHybridAppPreference () { + return this.getObject(HybridAppPreference, CloudAppProperties.KEY_HYBRID_APP_PREFERENCE); + } + + /** + * @param {String} endpoint - Specifies the endpoint which Core will attempt to connect to when this app is selected + * @return {CloudAppProperties} + */ + setEndpoint (endpoint) { + this.setParameter(CloudAppProperties.KEY_ENDPOINT, endpoint); + return this; + } + + /** + * @return {String} + */ + getEndpoint () { + return this.getParameter(CloudAppProperties.KEY_ENDPOINT); + } +} + +CloudAppProperties.KEY_NICKNAMES = 'nicknames'; +CloudAppProperties.KEY_APP_ID = 'appID'; +CloudAppProperties.KEY_ENABLED = 'enabled'; +CloudAppProperties.KEY_AUTH_TOKEN = 'authToken'; +CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE = 'cloudTransportType'; +CloudAppProperties.KEY_HYBRID_APP_PREFERENCE = 'hybridAppPreference'; +CloudAppProperties.KEY_ENDPOINT = 'endpoint'; + +export { CloudAppProperties }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ClusterModeStatus.js b/lib/js/src/rpc/structs/ClusterModeStatus.js new file mode 100644 index 00000000..028ea633 --- /dev/null +++ b/lib/js/src/rpc/structs/ClusterModeStatus.js @@ -0,0 +1,120 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { PowerModeStatus } from '../enums/PowerModeStatus.js'; +import { CarModeStatus } from '../enums/CarModeStatus.js'; +import { PowerModeQualificationStatus } from '../enums/PowerModeQualificationStatus.js'; + +class ClusterModeStatus extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} active - References signal "PowerMode_UB". + * @return {ClusterModeStatus} + */ + setPowerModeActive (active) { + this.setParameter(ClusterModeStatus.KEY_POWER_MODE_ACTIVE, active); + return this; + } + + /** + * @return {Boolean} + */ + getPowerModeActive () { + return this.getParameter(ClusterModeStatus.KEY_POWER_MODE_ACTIVE); + } + + /** + * @param {PowerModeQualificationStatus} status - References signal "PowerModeQF". See PowerModeQualificationStatus. + * @return {ClusterModeStatus} + */ + setPowerModeQualificationStatus (status) { + this.validateType(PowerModeQualificationStatus, status); + this.setParameter(ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS, status); + return this; + } + + /** + * @return {PowerModeQualificationStatus} + */ + getPowerModeQualificationStatus () { + return this.getObject(PowerModeQualificationStatus, ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS); + } + + /** + * @param {CarModeStatus} status - References signal "CarMode". See CarMode. + * @return {ClusterModeStatus} + */ + setCarModeStatus (status) { + this.validateType(CarModeStatus, status); + this.setParameter(ClusterModeStatus.KEY_CAR_MODE_STATUS, status); + return this; + } + + /** + * @return {CarModeStatus} + */ + getCarModeStatus () { + return this.getObject(CarModeStatus, ClusterModeStatus.KEY_CAR_MODE_STATUS); + } + + /** + * @param {PowerModeStatus} status - References signal "PowerMode". See PowerMode. + * @return {ClusterModeStatus} + */ + setPowerModeStatus (status) { + this.validateType(PowerModeStatus, status); + this.setParameter(ClusterModeStatus.KEY_POWER_MODE_STATUS, status); + return this; + } + + /** + * @return {PowerModeStatus} + */ + getPowerModeStatus () { + return this.getObject(PowerModeStatus, ClusterModeStatus.KEY_POWER_MODE_STATUS); + } +} + +ClusterModeStatus.KEY_POWER_MODE_ACTIVE = 'powerModeActive'; +ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS = 'powerModeQualificationStatus'; +ClusterModeStatus.KEY_CAR_MODE_STATUS = 'carModeStatus'; +ClusterModeStatus.KEY_POWER_MODE_STATUS = 'powerModeStatus'; + +export { ClusterModeStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/Coordinate.js b/lib/js/src/rpc/structs/Coordinate.js new file mode 100644 index 00000000..4c80f5ba --- /dev/null +++ b/lib/js/src/rpc/structs/Coordinate.js @@ -0,0 +1,80 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class Coordinate extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} degrees - Latitude of the location. + * @return {Coordinate} + */ + setLatitudeDegrees (degrees) { + this.setParameter(Coordinate.KEY_LATITUDE_DEGREES, degrees); + return this; + } + + /** + * @return {Number} + */ + getLatitudeDegrees () { + return this.getParameter(Coordinate.KEY_LATITUDE_DEGREES); + } + + /** + * @param {Number} degrees - Longitude of the location. + * @return {Coordinate} + */ + setLongitudeDegrees (degrees) { + this.setParameter(Coordinate.KEY_LONGITUDE_DEGREES, degrees); + return this; + } + + /** + * @return {Number} + */ + getLongitudeDegrees () { + return this.getParameter(Coordinate.KEY_LONGITUDE_DEGREES); + } +} + +Coordinate.KEY_LATITUDE_DEGREES = 'latitudeDegrees'; +Coordinate.KEY_LONGITUDE_DEGREES = 'longitudeDegrees'; + +export { Coordinate }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/DIDResult.js b/lib/js/src/rpc/structs/DIDResult.js new file mode 100644 index 00000000..a1f666f1 --- /dev/null +++ b/lib/js/src/rpc/structs/DIDResult.js @@ -0,0 +1,102 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { VehicleDataResultCode } from '../enums/VehicleDataResultCode.js'; + +/** + * Individual requested DID result and data + */ +class DIDResult extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {VehicleDataResultCode} code - Individual DID result code. + * @return {DIDResult} + */ + setResultCode (code) { + this.validateType(VehicleDataResultCode, code); + this.setParameter(DIDResult.KEY_RESULT_CODE, code); + return this; + } + + /** + * @return {VehicleDataResultCode} + */ + getResultCode () { + return this.getObject(VehicleDataResultCode, DIDResult.KEY_RESULT_CODE); + } + + /** + * @param {Number} location - Location of raw data from vehicle data DID + * @return {DIDResult} + */ + setDidLocation (location) { + this.setParameter(DIDResult.KEY_DID_LOCATION, location); + return this; + } + + /** + * @return {Number} + */ + getDidLocation () { + return this.getParameter(DIDResult.KEY_DID_LOCATION); + } + + /** + * @param {String} data - Raw DID-based data returned for requested element. + * @return {DIDResult} + */ + setData (data) { + this.setParameter(DIDResult.KEY_DATA, data); + return this; + } + + /** + * @return {String} + */ + getData () { + return this.getParameter(DIDResult.KEY_DATA); + } +} + +DIDResult.KEY_RESULT_CODE = 'resultCode'; +DIDResult.KEY_DID_LOCATION = 'didLocation'; +DIDResult.KEY_DATA = 'data'; + +export { DIDResult }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/DateTime.js b/lib/js/src/rpc/structs/DateTime.js new file mode 100644 index 00000000..3bee1b6d --- /dev/null +++ b/lib/js/src/rpc/structs/DateTime.js @@ -0,0 +1,199 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class DateTime extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} millisecond - Milliseconds + * @return {DateTime} + */ + setMillisecond (millisecond) { + this.setParameter(DateTime.KEY_MILLISECOND, millisecond); + return this; + } + + /** + * @return {Number} + */ + getMillisecond () { + return this.getParameter(DateTime.KEY_MILLISECOND); + } + + /** + * @param {Number} second - Seconds part of time + * @return {DateTime} + */ + setSecond (second) { + this.setParameter(DateTime.KEY_SECOND, second); + return this; + } + + /** + * @return {Number} + */ + getSecond () { + return this.getParameter(DateTime.KEY_SECOND); + } + + /** + * @param {Number} minute - Minutes part of time + * @return {DateTime} + */ + setMinute (minute) { + this.setParameter(DateTime.KEY_MINUTE, minute); + return this; + } + + /** + * @return {Number} + */ + getMinute () { + return this.getParameter(DateTime.KEY_MINUTE); + } + + /** + * @param {Number} hour - Hours part of time. Note that this structure accepts time only in 24 Hr format + * @return {DateTime} + */ + setHour (hour) { + this.setParameter(DateTime.KEY_HOUR, hour); + return this; + } + + /** + * @return {Number} + */ + getHour () { + return this.getParameter(DateTime.KEY_HOUR); + } + + /** + * @param {Number} day - Day of the month + * @return {DateTime} + */ + setDay (day) { + this.setParameter(DateTime.KEY_DAY, day); + return this; + } + + /** + * @return {Number} + */ + getDay () { + return this.getParameter(DateTime.KEY_DAY); + } + + /** + * @param {Number} month - Month of the year + * @return {DateTime} + */ + setMonth (month) { + this.setParameter(DateTime.KEY_MONTH, month); + return this; + } + + /** + * @return {Number} + */ + getMonth () { + return this.getParameter(DateTime.KEY_MONTH); + } + + /** + * @param {Number} year - The year in YYYY format + * @return {DateTime} + */ + setYear (year) { + this.setParameter(DateTime.KEY_YEAR, year); + return this; + } + + /** + * @return {Number} + */ + getYear () { + return this.getParameter(DateTime.KEY_YEAR); + } + + /** + * @param {Number} tz_hour - Time zone offset in Hours wrt UTC. + * @return {DateTime} + */ + setTz_hour (tz_hour) { + this.setParameter(DateTime.KEY_TZ_HOUR, tz_hour); + return this; + } + + /** + * @return {Number} + */ + getTz_hour () { + return this.getParameter(DateTime.KEY_TZ_HOUR); + } + + /** + * @param {Number} tz_minute - Time zone offset in Min wrt UTC. + * @return {DateTime} + */ + setTz_minute (tz_minute) { + this.setParameter(DateTime.KEY_TZ_MINUTE, tz_minute); + return this; + } + + /** + * @return {Number} + */ + getTz_minute () { + return this.getParameter(DateTime.KEY_TZ_MINUTE); + } +} + +DateTime.KEY_MILLISECOND = 'millisecond'; +DateTime.KEY_SECOND = 'second'; +DateTime.KEY_MINUTE = 'minute'; +DateTime.KEY_HOUR = 'hour'; +DateTime.KEY_DAY = 'day'; +DateTime.KEY_MONTH = 'month'; +DateTime.KEY_YEAR = 'year'; +DateTime.KEY_TZ_HOUR = 'tz_hour'; +DateTime.KEY_TZ_MINUTE = 'tz_minute'; + +export { DateTime }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/DeviceInfo.js b/lib/js/src/rpc/structs/DeviceInfo.js index 30158137..4f9b1a4e 100644 --- a/lib/js/src/rpc/structs/DeviceInfo.js +++ b/lib/js/src/rpc/structs/DeviceInfo.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,119 +33,109 @@ import { RpcStruct } from '../RpcStruct.js'; +/** + * Various information about connecting device. + */ class DeviceInfo extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {String} hardware - * @return {DeviceInfo} - */ + * @param {String} hardware - Device model + * @return {DeviceInfo} + */ setHardware (hardware) { - this.validateType(String, hardware); - this.setParameter(DeviceInfo.KEY_HARDWARE, hardware); return this; } /** - * @return {String} - */ + * @return {String} + */ getHardware () { return this.getParameter(DeviceInfo.KEY_HARDWARE); } - /** - * @param {String} firmwareRev - * @return {DeviceInfo} - */ - setFirmwareRev (firmwareRev) { - this.validateType(String, firmwareRev); - - this.setParameter(DeviceInfo.KEY_FIRMWARE_REV, firmwareRev); + * @param {String} rev - Device firmware revision + * @return {DeviceInfo} + */ + setFirmwareRev (rev) { + this.setParameter(DeviceInfo.KEY_FIRMWARE_REV, rev); return this; } /** - * @return {String} - */ + * @return {String} + */ getFirmwareRev () { return this.getParameter(DeviceInfo.KEY_FIRMWARE_REV); } - /** - * @param {String} os - * @return {DeviceInfo} - */ + * @param {String} os - Device OS + * @return {DeviceInfo} + */ setOs (os) { - this.validateType(String, os); - this.setParameter(DeviceInfo.KEY_OS, os); return this; } /** - * @return {String} - */ + * @return {String} + */ getOs () { return this.getParameter(DeviceInfo.KEY_OS); } /** - * @param {String} osVersion - * @return {DeviceInfo} - */ - setOsVersion (osVersion) { - this.validateType(String, osVersion); - - this.setParameter(DeviceInfo.KEY_OS_VERSION, osVersion); + * @param {String} version - Device OS version + * @return {DeviceInfo} + */ + setOsVersion (version) { + this.setParameter(DeviceInfo.KEY_OS_VERSION, version); return this; } /** - * @return {String} - */ + * @return {String} + */ getOsVersion () { return this.getParameter(DeviceInfo.KEY_OS_VERSION); } - /** - * @param {String} carrier - * @return {DeviceInfo} - */ + * @param {String} carrier - Device mobile carrier (if applicable) + * @return {DeviceInfo} + */ setCarrier (carrier) { - this.validateType(String, carrier); - this.setParameter(DeviceInfo.KEY_CARRIER, carrier); return this; } /** - * @return {String} - */ + * @return {String} + */ getCarrier () { return this.getParameter(DeviceInfo.KEY_CARRIER); } - /** - * @param {Number} maxNumberRFCOMMPorts - * @return {DeviceInfo} - */ - setMaxNumberRFCOMMPorts (maxNumberRFCOMMPorts) { - this.validateType(Number, maxNumberRFCOMMPorts); - - this.setParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS, maxNumberRFCOMMPorts); + * @param {Number} ports - Omitted if connected not via BT. + * @return {DeviceInfo} + */ + setMaxNumberRFCOMMPorts (ports) { + this.setParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS, ports); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getMaxNumberRFCOMMPorts () { return this.getParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS); } @@ -157,4 +148,4 @@ DeviceInfo.KEY_OS_VERSION = 'osVersion'; DeviceInfo.KEY_CARRIER = 'carrier'; DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS = 'maxNumberRFCOMMPorts'; -export { DeviceInfo }; +export { DeviceInfo }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/DeviceStatus.js b/lib/js/src/rpc/structs/DeviceStatus.js new file mode 100644 index 00000000..beb16575 --- /dev/null +++ b/lib/js/src/rpc/structs/DeviceStatus.js @@ -0,0 +1,240 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { PrimaryAudioSource } from '../enums/PrimaryAudioSource.js'; +import { DeviceLevelStatus } from '../enums/DeviceLevelStatus.js'; + +class DeviceStatus extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} on - References signal "CPM_VoiceRec_STAT". + * @return {DeviceStatus} + */ + setVoiceRecOn (on) { + this.setParameter(DeviceStatus.KEY_VOICE_REC_ON, on); + return this; + } + + /** + * @return {Boolean} + */ + getVoiceRecOn () { + return this.getParameter(DeviceStatus.KEY_VOICE_REC_ON); + } + + /** + * @param {Boolean} on - References signal "BT_ICON". + * @return {DeviceStatus} + */ + setBtIconOn (on) { + this.setParameter(DeviceStatus.KEY_BT_ICON_ON, on); + return this; + } + + /** + * @return {Boolean} + */ + getBtIconOn () { + return this.getParameter(DeviceStatus.KEY_BT_ICON_ON); + } + + /** + * @param {Boolean} active - References signal "CPM_Call_Active_STAT". + * @return {DeviceStatus} + */ + setCallActive (active) { + this.setParameter(DeviceStatus.KEY_CALL_ACTIVE, active); + return this; + } + + /** + * @return {Boolean} + */ + getCallActive () { + return this.getParameter(DeviceStatus.KEY_CALL_ACTIVE); + } + + /** + * @param {Boolean} roaming - References signal "CPM_Phone_Roaming_STAT". + * @return {DeviceStatus} + */ + setPhoneRoaming (roaming) { + this.setParameter(DeviceStatus.KEY_PHONE_ROAMING, roaming); + return this; + } + + /** + * @return {Boolean} + */ + getPhoneRoaming () { + return this.getParameter(DeviceStatus.KEY_PHONE_ROAMING); + } + + /** + * @param {Boolean} available - References signal "CPM_TextMsg_AVAL". + * @return {DeviceStatus} + */ + setTextMsgAvailable (available) { + this.setParameter(DeviceStatus.KEY_TEXT_MSG_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getTextMsgAvailable () { + return this.getParameter(DeviceStatus.KEY_TEXT_MSG_AVAILABLE); + } + + /** + * @param {DeviceLevelStatus} status - Device battery level status. References signal "CPM_Batt_Level_STAT". See + * DeviceLevelStatus. + * @return {DeviceStatus} + */ + setBattLevelStatus (status) { + this.validateType(DeviceLevelStatus, status); + this.setParameter(DeviceStatus.KEY_BATT_LEVEL_STATUS, status); + return this; + } + + /** + * @return {DeviceLevelStatus} + */ + getBattLevelStatus () { + return this.getObject(DeviceLevelStatus, DeviceStatus.KEY_BATT_LEVEL_STATUS); + } + + /** + * @param {Boolean} muted - References signal "CPM_Stereo_Audio_Output". + * @return {DeviceStatus} + */ + setStereoAudioOutputMuted (muted) { + this.setParameter(DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED, muted); + return this; + } + + /** + * @return {Boolean} + */ + getStereoAudioOutputMuted () { + return this.getParameter(DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED); + } + + /** + * @param {Boolean} muted - References signal "CPM_Mono_Audio_Output". + * @return {DeviceStatus} + */ + setMonoAudioOutputMuted (muted) { + this.setParameter(DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED, muted); + return this; + } + + /** + * @return {Boolean} + */ + getMonoAudioOutputMuted () { + return this.getParameter(DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED); + } + + /** + * @param {DeviceLevelStatus} status - Device signal level status. References signal "CPM_Signal_Strength_STAT". See + * DeviceLevelStatus. + * @return {DeviceStatus} + */ + setSignalLevelStatus (status) { + this.validateType(DeviceLevelStatus, status); + this.setParameter(DeviceStatus.KEY_SIGNAL_LEVEL_STATUS, status); + return this; + } + + /** + * @return {DeviceLevelStatus} + */ + getSignalLevelStatus () { + return this.getObject(DeviceLevelStatus, DeviceStatus.KEY_SIGNAL_LEVEL_STATUS); + } + + /** + * @param {PrimaryAudioSource} source - References signal "CPM_Stereo_PAS_Source". See PrimaryAudioSource. + * @return {DeviceStatus} + */ + setPrimaryAudioSource (source) { + this.validateType(PrimaryAudioSource, source); + this.setParameter(DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE, source); + return this; + } + + /** + * @return {PrimaryAudioSource} + */ + getPrimaryAudioSource () { + return this.getObject(PrimaryAudioSource, DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE); + } + + /** + * @param {Boolean} active - References signal "eCall_Event". + * @return {DeviceStatus} + */ + setECallEventActive (active) { + this.setParameter(DeviceStatus.KEY_E_CALL_EVENT_ACTIVE, active); + return this; + } + + /** + * @return {Boolean} + */ + getECallEventActive () { + return this.getParameter(DeviceStatus.KEY_E_CALL_EVENT_ACTIVE); + } +} + +DeviceStatus.KEY_VOICE_REC_ON = 'voiceRecOn'; +DeviceStatus.KEY_BT_ICON_ON = 'btIconOn'; +DeviceStatus.KEY_CALL_ACTIVE = 'callActive'; +DeviceStatus.KEY_PHONE_ROAMING = 'phoneRoaming'; +DeviceStatus.KEY_TEXT_MSG_AVAILABLE = 'textMsgAvailable'; +DeviceStatus.KEY_BATT_LEVEL_STATUS = 'battLevelStatus'; +DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED = 'stereoAudioOutputMuted'; +DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED = 'monoAudioOutputMuted'; +DeviceStatus.KEY_SIGNAL_LEVEL_STATUS = 'signalLevelStatus'; +DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE = 'primaryAudioSource'; +DeviceStatus.KEY_E_CALL_EVENT_ACTIVE = 'eCallEventActive'; + +export { DeviceStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/DisplayCapabilities.js b/lib/js/src/rpc/structs/DisplayCapabilities.js index 834fb3c2..a7c2cc77 100644 --- a/lib/js/src/rpc/structs/DisplayCapabilities.js +++ b/lib/js/src/rpc/structs/DisplayCapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,179 +31,192 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcStruct } from '../RpcStruct.js'; -import { TextField } from './TextField.js'; -import { ImageField } from './ImageField.js'; +import { MediaClockFormat } from '../enums/MediaClockFormat.js'; import { ScreenParams } from './ScreenParams.js'; +import { ImageField } from './ImageField.js'; +import { RpcStruct } from '../RpcStruct.js'; import { DisplayType } from '../enums/DisplayType.js'; -import { MediaClockFormat } from '../enums/MediaClockFormat.js'; +import { TextField } from './TextField.js'; +/** + * Contains information about the display capabilities. This struct is deprecated; please see the new SystemCapability + * DISPLAYS and corresponding struct DisplayCapability + * @deprecated + */ class DisplayCapabilities extends RpcStruct { + /** + * @deprecated + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {DisplayType} displayType - * @return {DisplayCapabilities} - */ - setDisplayType (displayType) { - this.validateType(DisplayType, displayType); - - this.setParameter(DisplayCapabilities.KEY_DISPLAY_TYPE, displayType); + * @deprecated + * @param {DisplayType} type - The type of the display. See DisplayType + * @return {DisplayCapabilities} + */ + setDisplayType (type) { + this.validateType(DisplayType, type); + this.setParameter(DisplayCapabilities.KEY_DISPLAY_TYPE, type); return this; } /** - * @return {DisplayType} - */ + * @deprecated + * @return {DisplayType} + */ getDisplayType () { return this.getObject(DisplayType, DisplayCapabilities.KEY_DISPLAY_TYPE); } - /** - * @param {String} displayName - * @return {DisplayCapabilities} - */ - setDisplayName (displayName) { - this.setParameter(DisplayCapabilities.KEY_DISPLAY_NAME, displayName); + * @deprecated + * @param {String} name - The name of the display the app is connected to. + * @return {DisplayCapabilities} + */ + setDisplayName (name) { + this.setParameter(DisplayCapabilities.KEY_DISPLAY_NAME, name); return this; } /** - * @return {String} - */ + * @deprecated + * @return {String} + */ getDisplayName () { return this.getParameter(DisplayCapabilities.KEY_DISPLAY_NAME); } /** - * @param {Array} textFields - * @return {DisplayCapabilities} - */ - setTextFields (textFields) { - // TODO make work with arrays - // this.validateType(TextField, textFields); - - this.setParameter(DisplayCapabilities.KEY_TEXT_FIELDS, textFields); + * @deprecated + * @param {TextField[]} fields - A set of all fields that support text data. See TextField + * @return {DisplayCapabilities} + */ + setTextFields (fields) { + this.validateType(TextField, fields, true); + this.setParameter(DisplayCapabilities.KEY_TEXT_FIELDS, fields); return this; } /** - * @return {Array} - */ + * @deprecated + * @return {TextField[]} + */ getTextFields () { return this.getObject(TextField, DisplayCapabilities.KEY_TEXT_FIELDS); } - /** - * @param {Array} imageFields - * @return {DisplayCapabilities} - */ - setImageFields (imageFields) { - // TODO make work with arrays - // this.validateType(ImageField, imageFields); - - this.setParameter(DisplayCapabilities.KEY_IMAGE_FIELDS, imageFields); + * @deprecated + * @param {ImageField[]} fields - A set of all fields that support images. See ImageField + * @return {DisplayCapabilities} + */ + setImageFields (fields) { + this.validateType(ImageField, fields, true); + this.setParameter(DisplayCapabilities.KEY_IMAGE_FIELDS, fields); return this; } /** - * @return {Array} - */ + * @deprecated + * @return {ImageField[]} + */ getImageFields () { return this.getObject(ImageField, DisplayCapabilities.KEY_IMAGE_FIELDS); } /** - * @param {Array} mediaClockFormats - * @return {DisplayCapabilities} - */ - setMediaClockFormats (mediaClockFormats) { - // TODO make work with arrays - // this.validateType(ImageField, mediaClockFormats); - - this.setParameter(DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS, mediaClockFormats); + * @deprecated + * @param {MediaClockFormat[]} formats - A set of all supported formats of the media clock. See MediaClockFormat + * @return {DisplayCapabilities} + */ + setMediaClockFormats (formats) { + this.validateType(MediaClockFormat, formats, true); + this.setParameter(DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS, formats); return this; } /** - * @return {Array} - */ + * @deprecated + * @return {MediaClockFormat[]} + */ getMediaClockFormats () { return this.getObject(MediaClockFormat, DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS); } - /** - * @param {Boolean} graphicSupported - * @return {DisplayCapabilities} - */ - setGraphicsSupported (graphicSupported) { - this.setParameter(DisplayCapabilities.KEY_GRAPHICS_SUPPORTED, graphicSupported); + * @deprecated + * @param {Boolean} supported - The display's persistent screen supports referencing a static or dynamic image. + * @return {DisplayCapabilities} + */ + setGraphicSupported (supported) { + this.setParameter(DisplayCapabilities.KEY_GRAPHIC_SUPPORTED, supported); return this; } /** - * @return {Boolean} - */ - getGraphicsSupported () { - return this.getParameter(DisplayCapabilities.KEY_GRAPHICS_SUPPORTED); + * @deprecated + * @return {Boolean} + */ + getGraphicSupported () { + return this.getParameter(DisplayCapabilities.KEY_GRAPHIC_SUPPORTED); } /** - * @param {Array} templatesAvailable - * @return {DisplayCapabilities} - */ - setTemplatesAvailable (templatesAvailable) { - // TODO make work with arrays - // this.validateType(String, templatesAvailable); - - this.setParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE, templatesAvailable); + * @deprecated + * @param {String[]} available - A set of all predefined persistent display templates available on headunit. To be + * referenced in SetDisplayLayout. + * @return {DisplayCapabilities} + */ + setTemplatesAvailable (available) { + this.setParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE, available); return this; } /** - * @return {Array} - */ + * @deprecated + * @return {String[]} + */ getTemplatesAvailable () { return this.getParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE); } /** - * @param {ScreenParams} screenParams - * @return {DisplayCapabilities} - */ - setScreenParams (screenParams) { - this.validateType(ScreenParams, screenParams); - - this.setParameter(DisplayCapabilities.KEY_SCREEN_PARAMS, screenParams); + * @deprecated + * @param {ScreenParams} params - A set of all parameters related to a prescribed screen area (e.g. for video / + * touch input). + * @return {DisplayCapabilities} + */ + setScreenParams (params) { + this.validateType(ScreenParams, params); + this.setParameter(DisplayCapabilities.KEY_SCREEN_PARAMS, params); return this; } /** - * @return {ScreenParams} - */ + * @deprecated + * @return {ScreenParams} + */ getScreenParams () { return this.getObject(ScreenParams, DisplayCapabilities.KEY_SCREEN_PARAMS); } - /** - * @param {Array} numCustomPresetsAvailable - * @return {DisplayCapabilities} - */ - setNumCustomPresetsAvailable (numCustomPresetsAvailable) { - // TODO make work with arrays - // this.validateType(Number, numCustomPresetsAvailable); - this.setParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, numCustomPresetsAvailable); + /** + * @deprecated + * @param {Number} available - The number of on-screen custom presets available (if any); otherwise omitted. + * @return {DisplayCapabilities} + */ + setNumCustomPresetsAvailable (available) { + this.setParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, available); return this; } /** - * @return {Array} - */ + * @deprecated + * @return {Number} + */ getNumCustomPresetsAvailable () { return this.getParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE); } @@ -213,9 +227,9 @@ DisplayCapabilities.KEY_DISPLAY_NAME = 'displayName'; DisplayCapabilities.KEY_TEXT_FIELDS = 'textFields'; DisplayCapabilities.KEY_IMAGE_FIELDS = 'imageFields'; DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS = 'mediaClockFormats'; -DisplayCapabilities.KEY_GRAPHICS_SUPPORTED = 'graphicSupported'; +DisplayCapabilities.KEY_GRAPHIC_SUPPORTED = 'graphicSupported'; DisplayCapabilities.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable'; DisplayCapabilities.KEY_SCREEN_PARAMS = 'screenParams'; DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable'; -export { DisplayCapabilities }; +export { DisplayCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/DisplayCapability.js b/lib/js/src/rpc/structs/DisplayCapability.js new file mode 100644 index 00000000..256b58e4 --- /dev/null +++ b/lib/js/src/rpc/structs/DisplayCapability.js @@ -0,0 +1,111 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { WindowTypeCapabilities } from './WindowTypeCapabilities.js'; +import { WindowCapability } from './WindowCapability.js'; +import { RpcStruct } from '../RpcStruct.js'; + +class DisplayCapability extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name + * @return {DisplayCapability} + */ + setDisplayName (name) { + this.setParameter(DisplayCapability.KEY_DISPLAY_NAME, name); + return this; + } + + /** + * @return {String} + */ + getDisplayName () { + return this.getParameter(DisplayCapability.KEY_DISPLAY_NAME); + } + + /** + * @param {WindowTypeCapabilities[]} supported - Informs the application how many windows the app is allowed to + * create per type. + * @return {DisplayCapability} + */ + setWindowTypeSupported (supported) { + this.validateType(WindowTypeCapabilities, supported, true); + this.setParameter(DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED, supported); + return this; + } + + /** + * @return {WindowTypeCapabilities[]} + */ + getWindowTypeSupported () { + return this.getObject(WindowTypeCapabilities, DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED); + } + + /** + * @param {WindowCapability[]} capabilities - Contains a list of capabilities of all windows related to the app. + * Once the app has registered the capabilities of all windows are + * provided. GetSystemCapability still allows requesting window + * capabilities of all windows. After registration, only windows with + * capabilities changed will be included. Following cases will cause only + * affected windows to be included: 1. App creates a new window. After + * the window is created, a system capability notification will be sent + * related only to the created window. 2. App sets a new layout to the + * window. The new layout changes window capabilties. The notification + * will reflect those changes to the single window. + * @return {DisplayCapability} + */ + setWindowCapabilities (capabilities) { + this.validateType(WindowCapability, capabilities, true); + this.setParameter(DisplayCapability.KEY_WINDOW_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {WindowCapability[]} + */ + getWindowCapabilities () { + return this.getObject(WindowCapability, DisplayCapability.KEY_WINDOW_CAPABILITIES); + } +} + +DisplayCapability.KEY_DISPLAY_NAME = 'displayName'; +DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED = 'windowTypeSupported'; +DisplayCapability.KEY_WINDOW_CAPABILITIES = 'windowCapabilities'; + +export { DisplayCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ECallInfo.js b/lib/js/src/rpc/structs/ECallInfo.js new file mode 100644 index 00000000..f1e0c47f --- /dev/null +++ b/lib/js/src/rpc/structs/ECallInfo.js @@ -0,0 +1,104 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { VehicleDataNotificationStatus } from '../enums/VehicleDataNotificationStatus.js'; +import { ECallConfirmationStatus } from '../enums/ECallConfirmationStatus.js'; + +class ECallInfo extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {VehicleDataNotificationStatus} status - References signal "eCallNotification_4A". See + * VehicleDataNotificationStatus. + * @return {ECallInfo} + */ + setECallNotificationStatus (status) { + this.validateType(VehicleDataNotificationStatus, status); + this.setParameter(ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS, status); + return this; + } + + /** + * @return {VehicleDataNotificationStatus} + */ + getECallNotificationStatus () { + return this.getObject(VehicleDataNotificationStatus, ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS); + } + + /** + * @param {VehicleDataNotificationStatus} status - References signal "eCallNotification". See + * VehicleDataNotificationStatus. + * @return {ECallInfo} + */ + setAuxECallNotificationStatus (status) { + this.validateType(VehicleDataNotificationStatus, status); + this.setParameter(ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS, status); + return this; + } + + /** + * @return {VehicleDataNotificationStatus} + */ + getAuxECallNotificationStatus () { + return this.getObject(VehicleDataNotificationStatus, ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS); + } + + /** + * @param {ECallConfirmationStatus} status - References signal "eCallConfirmation". See ECallConfirmationStatus. + * @return {ECallInfo} + */ + setECallConfirmationStatus (status) { + this.validateType(ECallConfirmationStatus, status); + this.setParameter(ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS, status); + return this; + } + + /** + * @return {ECallConfirmationStatus} + */ + getECallConfirmationStatus () { + return this.getObject(ECallConfirmationStatus, ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS); + } +} + +ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS = 'eCallNotificationStatus'; +ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS = 'auxECallNotificationStatus'; +ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS = 'eCallConfirmationStatus'; + +export { ECallInfo }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/EmergencyEvent.js b/lib/js/src/rpc/structs/EmergencyEvent.js new file mode 100644 index 00000000..04d28e4b --- /dev/null +++ b/lib/js/src/rpc/structs/EmergencyEvent.js @@ -0,0 +1,139 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { FuelCutoffStatus } from '../enums/FuelCutoffStatus.js'; +import { EmergencyEventType } from '../enums/EmergencyEventType.js'; +import { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js'; + +class EmergencyEvent extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {EmergencyEventType} type - References signal "VedsEvntType_D_Ltchd". See EmergencyEventType. + * @return {EmergencyEvent} + */ + setEmergencyEventType (type) { + this.validateType(EmergencyEventType, type); + this.setParameter(EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE, type); + return this; + } + + /** + * @return {EmergencyEventType} + */ + getEmergencyEventType () { + return this.getObject(EmergencyEventType, EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE); + } + + /** + * @param {FuelCutoffStatus} status - References signal "RCM_FuelCutoff". See FuelCutoffStatus. + * @return {EmergencyEvent} + */ + setFuelCutoffStatus (status) { + this.validateType(FuelCutoffStatus, status); + this.setParameter(EmergencyEvent.KEY_FUEL_CUTOFF_STATUS, status); + return this; + } + + /** + * @return {FuelCutoffStatus} + */ + getFuelCutoffStatus () { + return this.getObject(FuelCutoffStatus, EmergencyEvent.KEY_FUEL_CUTOFF_STATUS); + } + + /** + * @param {VehicleDataEventStatus} event - References signal "VedsEvntRoll_D_Ltchd". See VehicleDataEventStatus. + * @return {EmergencyEvent} + */ + setRolloverEvent (event) { + this.validateType(VehicleDataEventStatus, event); + this.setParameter(EmergencyEvent.KEY_ROLLOVER_EVENT, event); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getRolloverEvent () { + return this.getObject(VehicleDataEventStatus, EmergencyEvent.KEY_ROLLOVER_EVENT); + } + + /** + * @param {Number} velocity - References signal "VedsMaxDeltaV_D_Ltchd". Change in velocity in KPH. Additional + * reserved values: 0x00 No event 0xFE Not supported 0xFF Fault + * @return {EmergencyEvent} + */ + setMaximumChangeVelocity (velocity) { + this.setParameter(EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY, velocity); + return this; + } + + /** + * @return {Number} + */ + getMaximumChangeVelocity () { + return this.getParameter(EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY); + } + + /** + * @param {VehicleDataEventStatus} events - References signal "VedsMultiEvnt_D_Ltchd". See VehicleDataEventStatus. + * @return {EmergencyEvent} + */ + setMultipleEvents (events) { + this.validateType(VehicleDataEventStatus, events); + this.setParameter(EmergencyEvent.KEY_MULTIPLE_EVENTS, events); + return this; + } + + /** + * @return {VehicleDataEventStatus} + */ + getMultipleEvents () { + return this.getObject(VehicleDataEventStatus, EmergencyEvent.KEY_MULTIPLE_EVENTS); + } +} + +EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE = 'emergencyEventType'; +EmergencyEvent.KEY_FUEL_CUTOFF_STATUS = 'fuelCutoffStatus'; +EmergencyEvent.KEY_ROLLOVER_EVENT = 'rolloverEvent'; +EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY = 'maximumChangeVelocity'; +EmergencyEvent.KEY_MULTIPLE_EVENTS = 'multipleEvents'; + +export { EmergencyEvent }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/EqualizerSettings.js b/lib/js/src/rpc/structs/EqualizerSettings.js new file mode 100644 index 00000000..66de738b --- /dev/null +++ b/lib/js/src/rpc/structs/EqualizerSettings.js @@ -0,0 +1,100 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +/** + * Defines the each Equalizer channel settings. + */ +class EqualizerSettings extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} id + * @return {EqualizerSettings} + */ + setChannelId (id) { + this.setParameter(EqualizerSettings.KEY_CHANNEL_ID, id); + return this; + } + + /** + * @return {Number} + */ + getChannelId () { + return this.getParameter(EqualizerSettings.KEY_CHANNEL_ID); + } + + /** + * @param {String} name - read-only channel / frequency name (e.i. "Treble, Midrange, Bass" or "125 Hz") + * @return {EqualizerSettings} + */ + setChannelName (name) { + this.setParameter(EqualizerSettings.KEY_CHANNEL_NAME, name); + return this; + } + + /** + * @return {String} + */ + getChannelName () { + return this.getParameter(EqualizerSettings.KEY_CHANNEL_NAME); + } + + /** + * @param {Number} setting - Reflects the setting, from 0%-100%. + * @return {EqualizerSettings} + */ + setChannelSetting (setting) { + this.setParameter(EqualizerSettings.KEY_CHANNEL_SETTING, setting); + return this; + } + + /** + * @return {Number} + */ + getChannelSetting () { + return this.getParameter(EqualizerSettings.KEY_CHANNEL_SETTING); + } +} + +EqualizerSettings.KEY_CHANNEL_ID = 'channelId'; +EqualizerSettings.KEY_CHANNEL_NAME = 'channelName'; +EqualizerSettings.KEY_CHANNEL_SETTING = 'channelSetting'; + +export { EqualizerSettings }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/FuelRange.js b/lib/js/src/rpc/structs/FuelRange.js new file mode 100644 index 00000000..85be6e6d --- /dev/null +++ b/lib/js/src/rpc/structs/FuelRange.js @@ -0,0 +1,82 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { FuelType } from '../enums/FuelType.js'; + +class FuelRange extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {FuelType} type + * @return {FuelRange} + */ + setType (type) { + this.validateType(FuelType, type); + this.setParameter(FuelRange.KEY_TYPE, type); + return this; + } + + /** + * @return {FuelType} + */ + getType () { + return this.getObject(FuelType, FuelRange.KEY_TYPE); + } + + /** + * @param {Number} range - The estimate range in KM the vehicle can travel based on fuel level and consumption. + * @return {FuelRange} + */ + setRange (range) { + this.setParameter(FuelRange.KEY_RANGE, range); + return this; + } + + /** + * @return {Number} + */ + getRange () { + return this.getParameter(FuelRange.KEY_RANGE); + } +} + +FuelRange.KEY_TYPE = 'type'; +FuelRange.KEY_RANGE = 'range'; + +export { FuelRange }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/GPSData.js b/lib/js/src/rpc/structs/GPSData.js new file mode 100644 index 00000000..36323c69 --- /dev/null +++ b/lib/js/src/rpc/structs/GPSData.js @@ -0,0 +1,378 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { CompassDirection } from '../enums/CompassDirection.js'; +import { Dimension } from '../enums/Dimension.js'; + +/** + * Struct with the GPS data. + */ +class GPSData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} degrees + * @return {GPSData} + */ + setLongitudeDegrees (degrees) { + this.setParameter(GPSData.KEY_LONGITUDE_DEGREES, degrees); + return this; + } + + /** + * @return {Number} + */ + getLongitudeDegrees () { + return this.getParameter(GPSData.KEY_LONGITUDE_DEGREES); + } + + /** + * @param {Number} degrees + * @return {GPSData} + */ + setLatitudeDegrees (degrees) { + this.setParameter(GPSData.KEY_LATITUDE_DEGREES, degrees); + return this; + } + + /** + * @return {Number} + */ + getLatitudeDegrees () { + return this.getParameter(GPSData.KEY_LATITUDE_DEGREES); + } + + /** + * @param {Number} year - The current UTC year. + * @return {GPSData} + */ + setUtcYear (year) { + this.setParameter(GPSData.KEY_UTC_YEAR, year); + return this; + } + + /** + * @return {Number} + */ + getUtcYear () { + return this.getParameter(GPSData.KEY_UTC_YEAR); + } + + /** + * @param {Number} month - The current UTC month. + * @return {GPSData} + */ + setUtcMonth (month) { + this.setParameter(GPSData.KEY_UTC_MONTH, month); + return this; + } + + /** + * @return {Number} + */ + getUtcMonth () { + return this.getParameter(GPSData.KEY_UTC_MONTH); + } + + /** + * @param {Number} day - The current UTC day. + * @return {GPSData} + */ + setUtcDay (day) { + this.setParameter(GPSData.KEY_UTC_DAY, day); + return this; + } + + /** + * @return {Number} + */ + getUtcDay () { + return this.getParameter(GPSData.KEY_UTC_DAY); + } + + /** + * @param {Number} hours - The current UTC hour. + * @return {GPSData} + */ + setUtcHours (hours) { + this.setParameter(GPSData.KEY_UTC_HOURS, hours); + return this; + } + + /** + * @return {Number} + */ + getUtcHours () { + return this.getParameter(GPSData.KEY_UTC_HOURS); + } + + /** + * @param {Number} minutes - The current UTC minute. + * @return {GPSData} + */ + setUtcMinutes (minutes) { + this.setParameter(GPSData.KEY_UTC_MINUTES, minutes); + return this; + } + + /** + * @return {Number} + */ + getUtcMinutes () { + return this.getParameter(GPSData.KEY_UTC_MINUTES); + } + + /** + * @param {Number} seconds - The current UTC second. + * @return {GPSData} + */ + setUtcSeconds (seconds) { + this.setParameter(GPSData.KEY_UTC_SECONDS, seconds); + return this; + } + + /** + * @return {Number} + */ + getUtcSeconds () { + return this.getParameter(GPSData.KEY_UTC_SECONDS); + } + + /** + * @param {CompassDirection} direction - See CompassDirection. + * @return {GPSData} + */ + setCompassDirection (direction) { + this.validateType(CompassDirection, direction); + this.setParameter(GPSData.KEY_COMPASS_DIRECTION, direction); + return this; + } + + /** + * @return {CompassDirection} + */ + getCompassDirection () { + return this.getObject(CompassDirection, GPSData.KEY_COMPASS_DIRECTION); + } + + /** + * @param {Number} pdop - PDOP. If undefined or unavailable, then value shall be set to 0. + * @return {GPSData} + */ + setPdop (pdop) { + this.setParameter(GPSData.KEY_PDOP, pdop); + return this; + } + + /** + * @return {Number} + */ + getPdop () { + return this.getParameter(GPSData.KEY_PDOP); + } + + /** + * @param {Number} hdop - HDOP. If value is unknown, value shall be set to 0. + * @return {GPSData} + */ + setHdop (hdop) { + this.setParameter(GPSData.KEY_HDOP, hdop); + return this; + } + + /** + * @return {Number} + */ + getHdop () { + return this.getParameter(GPSData.KEY_HDOP); + } + + /** + * @param {Number} vdop - VDOP. If value is unknown, value shall be set to 0. + * @return {GPSData} + */ + setVdop (vdop) { + this.setParameter(GPSData.KEY_VDOP, vdop); + return this; + } + + /** + * @return {Number} + */ + getVdop () { + return this.getParameter(GPSData.KEY_VDOP); + } + + /** + * @param {Boolean} actual - True, if actual. False, if inferred. + * @return {GPSData} + */ + setActual (actual) { + this.setParameter(GPSData.KEY_ACTUAL, actual); + return this; + } + + /** + * @return {Boolean} + */ + getActual () { + return this.getParameter(GPSData.KEY_ACTUAL); + } + + /** + * @param {Number} satellites - Number of satellites in view + * @return {GPSData} + */ + setSatellites (satellites) { + this.setParameter(GPSData.KEY_SATELLITES, satellites); + return this; + } + + /** + * @return {Number} + */ + getSatellites () { + return this.getParameter(GPSData.KEY_SATELLITES); + } + + /** + * @param {Dimension} dimension - See Dimension + * @return {GPSData} + */ + setDimension (dimension) { + this.validateType(Dimension, dimension); + this.setParameter(GPSData.KEY_DIMENSION, dimension); + return this; + } + + /** + * @return {Dimension} + */ + getDimension () { + return this.getObject(Dimension, GPSData.KEY_DIMENSION); + } + + /** + * @param {Number} altitude - Altitude in meters + * @return {GPSData} + */ + setAltitude (altitude) { + this.setParameter(GPSData.KEY_ALTITUDE, altitude); + return this; + } + + /** + * @return {Number} + */ + getAltitude () { + return this.getParameter(GPSData.KEY_ALTITUDE); + } + + /** + * @param {Number} heading - The heading. North is 0. Resolution is 0.01 + * @return {GPSData} + */ + setHeading (heading) { + this.setParameter(GPSData.KEY_HEADING, heading); + return this; + } + + /** + * @return {Number} + */ + getHeading () { + return this.getParameter(GPSData.KEY_HEADING); + } + + /** + * @param {Number} speed - The speed in KPH + * @return {GPSData} + */ + setSpeed (speed) { + this.setParameter(GPSData.KEY_SPEED, speed); + return this; + } + + /** + * @return {Number} + */ + getSpeed () { + return this.getParameter(GPSData.KEY_SPEED); + } + + /** + * @param {Boolean} shifted - True, if GPS lat/long, time, and altitude have been purposefully shifted (requires a + * proprietary algorithm to unshift). False, if the GPS data is raw and un-shifted. If + * not provided, then value is assumed False. + * @return {GPSData} + */ + setShifted (shifted) { + this.setParameter(GPSData.KEY_SHIFTED, shifted); + return this; + } + + /** + * @return {Boolean} + */ + getShifted () { + return this.getParameter(GPSData.KEY_SHIFTED); + } +} + +GPSData.KEY_LONGITUDE_DEGREES = 'longitudeDegrees'; +GPSData.KEY_LATITUDE_DEGREES = 'latitudeDegrees'; +GPSData.KEY_UTC_YEAR = 'utcYear'; +GPSData.KEY_UTC_MONTH = 'utcMonth'; +GPSData.KEY_UTC_DAY = 'utcDay'; +GPSData.KEY_UTC_HOURS = 'utcHours'; +GPSData.KEY_UTC_MINUTES = 'utcMinutes'; +GPSData.KEY_UTC_SECONDS = 'utcSeconds'; +GPSData.KEY_COMPASS_DIRECTION = 'compassDirection'; +GPSData.KEY_PDOP = 'pdop'; +GPSData.KEY_HDOP = 'hdop'; +GPSData.KEY_VDOP = 'vdop'; +GPSData.KEY_ACTUAL = 'actual'; +GPSData.KEY_SATELLITES = 'satellites'; +GPSData.KEY_DIMENSION = 'dimension'; +GPSData.KEY_ALTITUDE = 'altitude'; +GPSData.KEY_HEADING = 'heading'; +GPSData.KEY_SPEED = 'speed'; +GPSData.KEY_SHIFTED = 'shifted'; + +export { GPSData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/Grid.js b/lib/js/src/rpc/structs/Grid.js index 61494ba6..e3d855b2 100644 --- a/lib/js/src/rpc/structs/Grid.js +++ b/lib/js/src/rpc/structs/Grid.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,103 +33,109 @@ import { RpcStruct } from '../RpcStruct.js'; +/** + * Describes a location (origin coordinates and span) of a vehicle component. + */ class Grid extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Number} column - * @return {Grid} - */ - setColumn (column) { - this.setParameter(Grid.KEY_COLUMN, column); + * @param {Number} col + * @return {Grid} + */ + setColumn (col) { + this.setParameter(Grid.KEY_COLUMN, col); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getColumn () { return this.getParameter(Grid.KEY_COLUMN); } /** - * @param {Number} row - * @return {Grid} - */ + * @param {Number} row + * @return {Grid} + */ setRow (row) { this.setParameter(Grid.KEY_ROW, row); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getRow () { return this.getParameter(Grid.KEY_ROW); } /** - * @param {Number} level - * @return {Grid} - */ + * @param {Number} level + * @return {Grid} + */ setLevel (level) { this.setParameter(Grid.KEY_LEVEL, level); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getLevel () { return this.getParameter(Grid.KEY_LEVEL); } /** - * @param {Number} columnSpan - * @return {Grid} - */ - setColumnSpan (columnSpan) { - this.setParameter(Grid.KEY_COLUMN_SPAN, columnSpan); + * @param {Number} colspan + * @return {Grid} + */ + setColumnSpan (colspan) { + this.setParameter(Grid.KEY_COLUMN_SPAN, colspan); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getColumnSpan () { return this.getParameter(Grid.KEY_COLUMN_SPAN); } /** - * @param {Number} rowSpan - * @return {Grid} - */ - setRowSpan (rowSpan) { - this.setParameter(Grid.KEY_ROW_SPAN, rowSpan); + * @param {Number} rowspan + * @return {Grid} + */ + setRowSpan (rowspan) { + this.setParameter(Grid.KEY_ROW_SPAN, rowspan); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getRowSpan () { return this.getParameter(Grid.KEY_ROW_SPAN); } /** - * @param {Number} levelSpan - * @return {Grid} - */ - setLevelSpan (levelSpan) { - this.setParameter(Grid.KEY_LEVEL_SPAN, levelSpan); + * @param {Number} levelspan + * @return {Grid} + */ + setLevelSpan (levelspan) { + this.setParameter(Grid.KEY_LEVEL_SPAN, levelspan); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getLevelSpan () { return this.getParameter(Grid.KEY_LEVEL_SPAN); } @@ -141,4 +148,4 @@ Grid.KEY_COLUMN_SPAN = 'colspan'; Grid.KEY_ROW_SPAN = 'rowspan'; Grid.KEY_LEVEL_SPAN = 'levelspan'; -export { Grid }; +export { Grid }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/HMICapabilities.js b/lib/js/src/rpc/structs/HMICapabilities.js index 5953d56b..757d3452 100644 --- a/lib/js/src/rpc/structs/HMICapabilities.js +++ b/lib/js/src/rpc/structs/HMICapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,122 +33,122 @@ import { RpcStruct } from '../RpcStruct.js'; - class HMICapabilities extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Boolean} navigation - * @return {HMICapabilities} - */ + * @param {Boolean} navigation - Availability of build in Nav. True: Available, False: Not Available + * @return {HMICapabilities} + */ setNavigation (navigation) { this.setParameter(HMICapabilities.KEY_NAVIGATION, navigation); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getNavigation () { return this.getParameter(HMICapabilities.KEY_NAVIGATION); } /** - * @param {Boolean} phoneCall - * @return {HMICapabilities} - */ - setPhoneCall (phoneCall) { - this.setParameter(HMICapabilities.KEY_PHONE_CALL, phoneCall); + * @param {Boolean} call - Availability of build in phone. True: Available, False: Not Available + * @return {HMICapabilities} + */ + setPhoneCall (call) { + this.setParameter(HMICapabilities.KEY_PHONE_CALL, call); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getPhoneCall () { return this.getParameter(HMICapabilities.KEY_PHONE_CALL); } /** - * @param {Boolean} videoStreaming - * @return {HMICapabilities} - */ - setVideoStreaming (videoStreaming) { - this.setParameter(HMICapabilities.KEY_VIDEO_STREAMING, videoStreaming); + * @param {Boolean} streaming - Availability of video streaming. + * @return {HMICapabilities} + */ + setVideoStreaming (streaming) { + this.setParameter(HMICapabilities.KEY_VIDEO_STREAMING, streaming); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getVideoStreaming () { return this.getParameter(HMICapabilities.KEY_VIDEO_STREAMING); } /** - * @param {Boolean} remoteControl - * @return {HMICapabilities} - */ - setRemoteControl (remoteControl) { - this.setParameter(HMICapabilities.KEY_REMOTE_CONTROL, remoteControl); + * @param {Boolean} control - Availability of remote control feature. True: Available, False: Not Available + * @return {HMICapabilities} + */ + setRemoteControl (control) { + this.setParameter(HMICapabilities.KEY_REMOTE_CONTROL, control); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getRemoteControl () { return this.getParameter(HMICapabilities.KEY_REMOTE_CONTROL); } /** - * @param {Boolean} appServices - * @return {HMICapabilities} - */ - setAppService (appServices) { - this.setParameter(HMICapabilities.KEY_APP_SERVICES, appServices); + * @param {Boolean} services - Availability of App Services functionality. True: Available, False: Not Available + * @return {HMICapabilities} + */ + setAppServices (services) { + this.setParameter(HMICapabilities.KEY_APP_SERVICES, services); return this; } /** - * @return {Boolean} - */ - getAppService () { + * @return {Boolean} + */ + getAppServices () { return this.getParameter(HMICapabilities.KEY_APP_SERVICES); } - /** - * @param {Boolean} displays - * @return {HMICapabilities} - */ + * @param {Boolean} displays - Availability of displays capability. True: Available, False: Not Available + * @return {HMICapabilities} + */ setDisplays (displays) { this.setParameter(HMICapabilities.KEY_DISPLAYS, displays); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getDisplays () { return this.getParameter(HMICapabilities.KEY_DISPLAYS); } - /** - * @param {Boolean} seatLocation - * @return {HMICapabilities} - */ - setSeatLocation (seatLocation) { - this.setParameter(HMICapabilities.KEY_SEAT_LOCATION, seatLocation); + * @param {Boolean} location - Availability of seat location feature. True: Available, False: Not Available + * @return {HMICapabilities} + */ + setSeatLocation (location) { + this.setParameter(HMICapabilities.KEY_SEAT_LOCATION, location); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getSeatLocation () { return this.getParameter(HMICapabilities.KEY_SEAT_LOCATION); } @@ -161,4 +162,4 @@ HMICapabilities.KEY_APP_SERVICES = 'appServices'; HMICapabilities.KEY_DISPLAYS = 'displays'; HMICapabilities.KEY_SEAT_LOCATION = 'seatLocation'; -export { HMICapabilities }; +export { HMICapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/HMIPermissions.js b/lib/js/src/rpc/structs/HMIPermissions.js new file mode 100644 index 00000000..7fab06c9 --- /dev/null +++ b/lib/js/src/rpc/structs/HMIPermissions.js @@ -0,0 +1,83 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { HMILevel } from '../enums/HMILevel.js'; +import { RpcStruct } from '../RpcStruct.js'; + +class HMIPermissions extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {HMILevel[]} allowed - A set of all HMI levels that are permitted for this given RPC. + * @return {HMIPermissions} + */ + setAllowed (allowed) { + this.validateType(HMILevel, allowed, true); + this.setParameter(HMIPermissions.KEY_ALLOWED, allowed); + return this; + } + + /** + * @return {HMILevel[]} + */ + getAllowed () { + return this.getObject(HMILevel, HMIPermissions.KEY_ALLOWED); + } + + /** + * @param {HMILevel[]} disallowed - A set of all HMI levels that are prohibited for this given RPC. + * @return {HMIPermissions} + */ + setUserDisallowed (disallowed) { + this.validateType(HMILevel, disallowed, true); + this.setParameter(HMIPermissions.KEY_USER_DISALLOWED, disallowed); + return this; + } + + /** + * @return {HMILevel[]} + */ + getUserDisallowed () { + return this.getObject(HMILevel, HMIPermissions.KEY_USER_DISALLOWED); + } +} + +HMIPermissions.KEY_ALLOWED = 'allowed'; +HMIPermissions.KEY_USER_DISALLOWED = 'userDisallowed'; + +export { HMIPermissions }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/HMISettingsControlCapabilities.js b/lib/js/src/rpc/structs/HMISettingsControlCapabilities.js new file mode 100644 index 00000000..50707982 --- /dev/null +++ b/lib/js/src/rpc/structs/HMISettingsControlCapabilities.js @@ -0,0 +1,134 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { ModuleInfo } from './ModuleInfo.js'; + +class HMISettingsControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - The short friendly name of the hmi setting module. It should not be used to identify a + * module by mobile application. + * @return {HMISettingsControlCapabilities} + */ + setModuleName (name) { + this.setParameter(HMISettingsControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getModuleName () { + return this.getParameter(HMISettingsControlCapabilities.KEY_MODULE_NAME); + } + + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {HMISettingsControlCapabilities} + */ + setModuleInfo (info) { + this.validateType(ModuleInfo, info); + this.setParameter(HMISettingsControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + + /** + * @return {ModuleInfo} + */ + getModuleInfo () { + return this.getObject(ModuleInfo, HMISettingsControlCapabilities.KEY_MODULE_INFO); + } + + /** + * @param {Boolean} available - Availability of the control of distance unit. + * @return {HMISettingsControlCapabilities} + */ + setDistanceUnitAvailable (available) { + this.setParameter(HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getDistanceUnitAvailable () { + return this.getParameter(HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of temperature unit. + * @return {HMISettingsControlCapabilities} + */ + setTemperatureUnitAvailable (available) { + this.setParameter(HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getTemperatureUnitAvailable () { + return this.getParameter(HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of HMI display mode. + * @return {HMISettingsControlCapabilities} + */ + setDisplayModeUnitAvailable (available) { + this.setParameter(HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getDisplayModeUnitAvailable () { + return this.getParameter(HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE); + } +} + +HMISettingsControlCapabilities.KEY_MODULE_NAME = 'moduleName'; +HMISettingsControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; +HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE = 'distanceUnitAvailable'; +HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE = 'temperatureUnitAvailable'; +HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE = 'displayModeUnitAvailable'; + +export { HMISettingsControlCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/HMISettingsControlData.js b/lib/js/src/rpc/structs/HMISettingsControlData.js new file mode 100644 index 00000000..6fc066be --- /dev/null +++ b/lib/js/src/rpc/structs/HMISettingsControlData.js @@ -0,0 +1,106 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { DisplayMode } from '../enums/DisplayMode.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { DistanceUnit } from '../enums/DistanceUnit.js'; +import { TemperatureUnit } from '../enums/TemperatureUnit.js'; + +/** + * Corresponds to "HMI_SETTINGS" ModuleType + */ +class HMISettingsControlData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {DisplayMode} mode + * @return {HMISettingsControlData} + */ + setDisplayMode (mode) { + this.validateType(DisplayMode, mode); + this.setParameter(HMISettingsControlData.KEY_DISPLAY_MODE, mode); + return this; + } + + /** + * @return {DisplayMode} + */ + getDisplayMode () { + return this.getObject(DisplayMode, HMISettingsControlData.KEY_DISPLAY_MODE); + } + + /** + * @param {TemperatureUnit} unit + * @return {HMISettingsControlData} + */ + setTemperatureUnit (unit) { + this.validateType(TemperatureUnit, unit); + this.setParameter(HMISettingsControlData.KEY_TEMPERATURE_UNIT, unit); + return this; + } + + /** + * @return {TemperatureUnit} + */ + getTemperatureUnit () { + return this.getObject(TemperatureUnit, HMISettingsControlData.KEY_TEMPERATURE_UNIT); + } + + /** + * @param {DistanceUnit} unit + * @return {HMISettingsControlData} + */ + setDistanceUnit (unit) { + this.validateType(DistanceUnit, unit); + this.setParameter(HMISettingsControlData.KEY_DISTANCE_UNIT, unit); + return this; + } + + /** + * @return {DistanceUnit} + */ + getDistanceUnit () { + return this.getObject(DistanceUnit, HMISettingsControlData.KEY_DISTANCE_UNIT); + } +} + +HMISettingsControlData.KEY_DISPLAY_MODE = 'displayMode'; +HMISettingsControlData.KEY_TEMPERATURE_UNIT = 'temperatureUnit'; +HMISettingsControlData.KEY_DISTANCE_UNIT = 'distanceUnit'; + +export { HMISettingsControlData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/HapticRect.js b/lib/js/src/rpc/structs/HapticRect.js new file mode 100644 index 00000000..1f91bd10 --- /dev/null +++ b/lib/js/src/rpc/structs/HapticRect.js @@ -0,0 +1,86 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Rectangle } from './Rectangle.js'; +import { RpcStruct } from '../RpcStruct.js'; + +/** + * Defines haptic data for each user control object for video streaming application + */ +class HapticRect extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} id - A user control spatial identifier + * @return {HapticRect} + */ + setId (id) { + this.setParameter(HapticRect.KEY_ID, id); + return this; + } + + /** + * @return {Number} + */ + getId () { + return this.getParameter(HapticRect.KEY_ID); + } + + /** + * @param {Rectangle} rect - The position of the haptic rectangle to be highlighted. The center of this rectangle + * will be "touched" when a press occurs. + * @return {HapticRect} + */ + setRect (rect) { + this.validateType(Rectangle, rect); + this.setParameter(HapticRect.KEY_RECT, rect); + return this; + } + + /** + * @return {Rectangle} + */ + getRect () { + return this.getObject(Rectangle, HapticRect.KEY_RECT); + } +} + +HapticRect.KEY_ID = 'id'; +HapticRect.KEY_RECT = 'rect'; + +export { HapticRect }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/HeadLampStatus.js b/lib/js/src/rpc/structs/HeadLampStatus.js new file mode 100644 index 00000000..a6bbd3bb --- /dev/null +++ b/lib/js/src/rpc/structs/HeadLampStatus.js @@ -0,0 +1,99 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { AmbientLightStatus } from '../enums/AmbientLightStatus.js'; + +class HeadLampStatus extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} on - Status of the low beam lamps. References signal "HeadLampLoActv_B_Stat". + * @return {HeadLampStatus} + */ + setLowBeamsOn (on) { + this.setParameter(HeadLampStatus.KEY_LOW_BEAMS_ON, on); + return this; + } + + /** + * @return {Boolean} + */ + getLowBeamsOn () { + return this.getParameter(HeadLampStatus.KEY_LOW_BEAMS_ON); + } + + /** + * @param {Boolean} on - Status of the high beam lamps. References signal "HeadLghtHiOn_B_Stat". + * @return {HeadLampStatus} + */ + setHighBeamsOn (on) { + this.setParameter(HeadLampStatus.KEY_HIGH_BEAMS_ON, on); + return this; + } + + /** + * @return {Boolean} + */ + getHighBeamsOn () { + return this.getParameter(HeadLampStatus.KEY_HIGH_BEAMS_ON); + } + + /** + * @param {AmbientLightStatus} status - Status of the ambient light sensor. + * @return {HeadLampStatus} + */ + setAmbientLightSensorStatus (status) { + this.validateType(AmbientLightStatus, status); + this.setParameter(HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS, status); + return this; + } + + /** + * @return {AmbientLightStatus} + */ + getAmbientLightSensorStatus () { + return this.getObject(AmbientLightStatus, HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS); + } +} + +HeadLampStatus.KEY_LOW_BEAMS_ON = 'lowBeamsOn'; +HeadLampStatus.KEY_HIGH_BEAMS_ON = 'highBeamsOn'; +HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS = 'ambientLightSensorStatus'; + +export { HeadLampStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/Image.js b/lib/js/src/rpc/structs/Image.js index 49c70264..0a9bfae1 100644 --- a/lib/js/src/rpc/structs/Image.js +++ b/lib/js/src/rpc/structs/Image.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -35,58 +36,58 @@ import { ImageType } from '../enums/ImageType.js'; class Image extends RpcStruct { /** - * @constructor - */ + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {String} value - * @return {Image} - */ + * @param {String} value - Either the static hex icon value or the binary image file name identifier (sent by + * PutFile). + * @return {Image} + */ setValue (value) { this.setParameter(Image.KEY_VALUE, value); return this; } /** - * @return {String} - */ + * @return {String} + */ getValue () { return this.getParameter(Image.KEY_VALUE); } /** - * @param {ImageType} type - * @return {Image} - */ + * @param {ImageType} type - Describes, whether it is a static or dynamic image. + * @return {Image} + */ setImageType (type) { this.validateType(ImageType, type); - this.setParameter(Image.KEY_IMAGE_TYPE, type); return this; } /** - * @return {ImageType} - */ + * @return {ImageType} + */ getImageType () { return this.getObject(ImageType, Image.KEY_IMAGE_TYPE); } /** - * @param {Boolean} isTemplate - * @return {Image} - */ - setIsTemplate (isTemplate) { - this.setParameter(Image.KEY_IS_TEMPLATE, isTemplate); + * @param {Boolean} template - If true, the image is a template image and can be recolored by the HMI + * @return {Image} + */ + setIsTemplate (template) { + this.setParameter(Image.KEY_IS_TEMPLATE, template); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getIsTemplate () { return this.getParameter(Image.KEY_IS_TEMPLATE); } @@ -96,4 +97,4 @@ Image.KEY_VALUE = 'value'; Image.KEY_IMAGE_TYPE = 'imageType'; Image.KEY_IS_TEMPLATE = 'isTemplate'; -export { Image }; +export { Image }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ImageField.js b/lib/js/src/rpc/structs/ImageField.js index bba8e1f3..0060d680 100644 --- a/lib/js/src/rpc/structs/ImageField.js +++ b/lib/js/src/rpc/structs/ImageField.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,64 +33,64 @@ import { RpcStruct } from '../RpcStruct.js'; import { ImageResolution } from './ImageResolution.js'; -import { FileType } from '../enums/FileType.js'; import { ImageFieldName } from '../enums/ImageFieldName.js'; +import { FileType } from '../enums/FileType.js'; class ImageField extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {ImageFieldName} imageFieldName - * @return {ImageField} - */ - setImageFieldName (imageFieldName) { - this.validateType(ImageFieldName, imageFieldName); - - this.setParameter(ImageField.KEY_NAME, imageFieldName); + * @param {ImageFieldName} name - The name that identifies the field. See ImageFieldName. + * @return {ImageField} + */ + setName (name) { + this.validateType(ImageFieldName, name); + this.setParameter(ImageField.KEY_NAME, name); return this; } /** - * @return {ImageFieldName} - */ - getImageFieldName () { + * @return {ImageFieldName} + */ + getName () { return this.getObject(ImageFieldName, ImageField.KEY_NAME); } /** - * @param {FileType[]} imageTypeSupported - * @return {ImageField} - */ - setImageTypeSupported (imageTypeSupported) { - this.validateType(FileType, imageTypeSupported, true); - - this.setParameter(ImageField.KEY_IMAGE_TYPE_SUPPORTED, imageTypeSupported); + * @param {FileType[]} supported - The image types that are supported in this field. See FileType. + * @return {ImageField} + */ + setImageTypeSupported (supported) { + this.validateType(FileType, supported, true); + this.setParameter(ImageField.KEY_IMAGE_TYPE_SUPPORTED, supported); return this; } /** - * @return {FileType} - */ + * @return {FileType[]} + */ getImageTypeSupported () { return this.getObject(FileType, ImageField.KEY_IMAGE_TYPE_SUPPORTED); } /** - * @param {ImageResolution} imageResolution - * @return {ImageField} - */ - setImageResolution (imageResolution) { - this.validateType(ImageResolution, imageResolution); - - this.setParameter(ImageField.KEY_IMAGE_RESOLUTION, imageResolution); + * @param {ImageResolution} resolution - The image resolution of this field. + * @return {ImageField} + */ + setImageResolution (resolution) { + this.validateType(ImageResolution, resolution); + this.setParameter(ImageField.KEY_IMAGE_RESOLUTION, resolution); return this; } /** - * @return {ImageResolution} - */ + * @return {ImageResolution} + */ getImageResolution () { return this.getObject(ImageResolution, ImageField.KEY_IMAGE_RESOLUTION); } @@ -99,4 +100,4 @@ ImageField.KEY_NAME = 'name'; ImageField.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported'; ImageField.KEY_IMAGE_RESOLUTION = 'imageResolution'; -export { ImageField }; +export { ImageField }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ImageResolution.js b/lib/js/src/rpc/structs/ImageResolution.js index 59a93fd9..7ed7e2ac 100644 --- a/lib/js/src/rpc/structs/ImageResolution.js +++ b/lib/js/src/rpc/structs/ImageResolution.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,38 +34,41 @@ import { RpcStruct } from '../RpcStruct.js'; class ImageResolution extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Number} resolutionWidth - * @return {ImageResolution} - */ - setResolutionWidth (resolutionWidth) { - this.setParameter(ImageResolution.KEY_RESOLUTION_WIDTH, resolutionWidth); + * @param {Number} width - The image resolution width. + * @return {ImageResolution} + */ + setResolutionWidth (width) { + this.setParameter(ImageResolution.KEY_RESOLUTION_WIDTH, width); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getResolutionWidth () { return this.getParameter(ImageResolution.KEY_RESOLUTION_WIDTH); } /** - * @param {Number} resolutionHeight - * @return {ImageResolution} - */ - setResolutionHeight (resolutionHeight) { - this.setParameter(ImageResolution.KEY_RESOLUTION_HEIGHT, resolutionHeight); + * @param {Number} height - The image resolution height. + * @return {ImageResolution} + */ + setResolutionHeight (height) { + this.setParameter(ImageResolution.KEY_RESOLUTION_HEIGHT, height); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getResolutionHeight () { return this.getParameter(ImageResolution.KEY_RESOLUTION_HEIGHT); } @@ -73,4 +77,4 @@ class ImageResolution extends RpcStruct { ImageResolution.KEY_RESOLUTION_WIDTH = 'resolutionWidth'; ImageResolution.KEY_RESOLUTION_HEIGHT = 'resolutionHeight'; -export { ImageResolution }; +export { ImageResolution }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/KeyboardProperties.js b/lib/js/src/rpc/structs/KeyboardProperties.js new file mode 100644 index 00000000..4a373ebb --- /dev/null +++ b/lib/js/src/rpc/structs/KeyboardProperties.js @@ -0,0 +1,160 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { KeyboardLayout } from '../enums/KeyboardLayout.js'; +import { Language } from '../enums/Language.js'; +import { KeypressMode } from '../enums/KeypressMode.js'; + +/** + * Configuration of on-screen keyboard (if available). + */ +class KeyboardProperties extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Language} language - The keyboard language. + * @return {KeyboardProperties} + */ + setLanguage (language) { + this.validateType(Language, language); + this.setParameter(KeyboardProperties.KEY_LANGUAGE, language); + return this; + } + + /** + * @return {Language} + */ + getLanguage () { + return this.getObject(Language, KeyboardProperties.KEY_LANGUAGE); + } + + /** + * @param {KeyboardLayout} layout - Desired keyboard layout. + * @return {KeyboardProperties} + */ + setKeyboardLayout (layout) { + this.validateType(KeyboardLayout, layout); + this.setParameter(KeyboardProperties.KEY_KEYBOARD_LAYOUT, layout); + return this; + } + + /** + * @return {KeyboardLayout} + */ + getKeyboardLayout () { + return this.getObject(KeyboardLayout, KeyboardProperties.KEY_KEYBOARD_LAYOUT); + } + + /** + * @param {KeypressMode} mode - Desired keypress mode. If omitted, this value will be set to RESEND_CURRENT_ENTRY. + * @return {KeyboardProperties} + */ + setKeypressMode (mode) { + this.validateType(KeypressMode, mode); + this.setParameter(KeyboardProperties.KEY_KEYPRESS_MODE, mode); + return this; + } + + /** + * @return {KeypressMode} + */ + getKeypressMode () { + return this.getObject(KeypressMode, KeyboardProperties.KEY_KEYPRESS_MODE); + } + + /** + * @param {String[]} list - Array of keyboard characters to enable. All omitted characters will be greyed out + * (disabled) on the keyboard. If omitted, the entire keyboard will be enabled. + * @return {KeyboardProperties} + */ + setLimitedCharacterList (list) { + this.setParameter(KeyboardProperties.KEY_LIMITED_CHARACTER_LIST, list); + return this; + } + + /** + * @return {String[]} + */ + getLimitedCharacterList () { + return this.getParameter(KeyboardProperties.KEY_LIMITED_CHARACTER_LIST); + } + + /** + * @param {String} text - Deprecated, use autoCompleteList instead. + * @return {KeyboardProperties} + */ + setAutoCompleteText (text) { + this.setParameter(KeyboardProperties.KEY_AUTO_COMPLETE_TEXT, text); + return this; + } + + /** + * @return {String} + */ + getAutoCompleteText () { + return this.getParameter(KeyboardProperties.KEY_AUTO_COMPLETE_TEXT); + } + + /** + * @param {String[]} list - Allows an app to prepopulate the text field with a list of suggested or completed + * entries as the user types. If empty, the auto-complete list will be removed from the + * screen. + * @return {KeyboardProperties} + */ + setAutoCompleteList (list) { + this.setParameter(KeyboardProperties.KEY_AUTO_COMPLETE_LIST, list); + return this; + } + + /** + * @return {String[]} + */ + getAutoCompleteList () { + return this.getParameter(KeyboardProperties.KEY_AUTO_COMPLETE_LIST); + } +} + +KeyboardProperties.KEY_LANGUAGE = 'language'; +KeyboardProperties.KEY_KEYBOARD_LAYOUT = 'keyboardLayout'; +KeyboardProperties.KEY_KEYPRESS_MODE = 'keypressMode'; +KeyboardProperties.KEY_LIMITED_CHARACTER_LIST = 'limitedCharacterList'; +KeyboardProperties.KEY_AUTO_COMPLETE_TEXT = 'autoCompleteText'; +KeyboardProperties.KEY_AUTO_COMPLETE_LIST = 'autoCompleteList'; + +export { KeyboardProperties }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/LightCapabilities.js b/lib/js/src/rpc/structs/LightCapabilities.js new file mode 100644 index 00000000..0ee890be --- /dev/null +++ b/lib/js/src/rpc/structs/LightCapabilities.js @@ -0,0 +1,117 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { LightName } from '../enums/LightName.js'; + +class LightCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {LightName} name + * @return {LightCapabilities} + */ + setName (name) { + this.validateType(LightName, name); + this.setParameter(LightCapabilities.KEY_NAME, name); + return this; + } + + /** + * @return {LightName} + */ + getName () { + return this.getObject(LightName, LightCapabilities.KEY_NAME); + } + + /** + * @param {Boolean} available - Indicates if the status (ON/OFF) can be set remotely. App shall not use read-only + * values (RAMP_UP/RAMP_DOWN/UNKNOWN/INVALID) in a setInteriorVehicleData request. + * @return {LightCapabilities} + */ + setStatusAvailable (available) { + this.setParameter(LightCapabilities.KEY_STATUS_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getStatusAvailable () { + return this.getParameter(LightCapabilities.KEY_STATUS_AVAILABLE); + } + + /** + * @param {Boolean} available - Indicates if the light's density can be set remotely (similar to a dimmer). + * @return {LightCapabilities} + */ + setDensityAvailable (available) { + this.setParameter(LightCapabilities.KEY_DENSITY_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getDensityAvailable () { + return this.getParameter(LightCapabilities.KEY_DENSITY_AVAILABLE); + } + + /** + * @param {Boolean} available - Indicates if the light's color can be set remotely by using the sRGB color space. + * @return {LightCapabilities} + */ + setRgbColorSpaceAvailable (available) { + this.setParameter(LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getRgbColorSpaceAvailable () { + return this.getParameter(LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE); + } +} + +LightCapabilities.KEY_NAME = 'name'; +LightCapabilities.KEY_STATUS_AVAILABLE = 'statusAvailable'; +LightCapabilities.KEY_DENSITY_AVAILABLE = 'densityAvailable'; +LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE = 'rgbColorSpaceAvailable'; + +export { LightCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/LightControlCapabilities.js b/lib/js/src/rpc/structs/LightControlCapabilities.js new file mode 100644 index 00000000..94571be7 --- /dev/null +++ b/lib/js/src/rpc/structs/LightControlCapabilities.js @@ -0,0 +1,102 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { LightCapabilities } from './LightCapabilities.js'; +import { ModuleInfo } from './ModuleInfo.js'; + +class LightControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - The short friendly name of the light control module. It should not be used to identify a + * module by mobile application. + * @return {LightControlCapabilities} + */ + setModuleName (name) { + this.setParameter(LightControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getModuleName () { + return this.getParameter(LightControlCapabilities.KEY_MODULE_NAME); + } + + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {LightControlCapabilities} + */ + setModuleInfo (info) { + this.validateType(ModuleInfo, info); + this.setParameter(LightControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + + /** + * @return {ModuleInfo} + */ + getModuleInfo () { + return this.getObject(ModuleInfo, LightControlCapabilities.KEY_MODULE_INFO); + } + + /** + * @param {LightCapabilities[]} lights - An array of available LightCapabilities that are controllable. + * @return {LightControlCapabilities} + */ + setSupportedLights (lights) { + this.validateType(LightCapabilities, lights, true); + this.setParameter(LightControlCapabilities.KEY_SUPPORTED_LIGHTS, lights); + return this; + } + + /** + * @return {LightCapabilities[]} + */ + getSupportedLights () { + return this.getObject(LightCapabilities, LightControlCapabilities.KEY_SUPPORTED_LIGHTS); + } +} + +LightControlCapabilities.KEY_MODULE_NAME = 'moduleName'; +LightControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; +LightControlCapabilities.KEY_SUPPORTED_LIGHTS = 'supportedLights'; + +export { LightControlCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/LightControlData.js b/lib/js/src/rpc/structs/LightControlData.js new file mode 100644 index 00000000..5a968d7c --- /dev/null +++ b/lib/js/src/rpc/structs/LightControlData.js @@ -0,0 +1,66 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { LightState } from './LightState.js'; + +class LightControlData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {LightState[]} state - An array of LightNames and their current or desired status. No change to the status + * of the LightNames that are not listed in the array. + * @return {LightControlData} + */ + setLightState (state) { + this.validateType(LightState, state, true); + this.setParameter(LightControlData.KEY_LIGHT_STATE, state); + return this; + } + + /** + * @return {LightState[]} + */ + getLightState () { + return this.getObject(LightState, LightControlData.KEY_LIGHT_STATE); + } +} + +LightControlData.KEY_LIGHT_STATE = 'lightState'; + +export { LightControlData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/LightState.js b/lib/js/src/rpc/structs/LightState.js new file mode 100644 index 00000000..af2fc8d7 --- /dev/null +++ b/lib/js/src/rpc/structs/LightState.js @@ -0,0 +1,120 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { LightStatus } from '../enums/LightStatus.js'; +import { LightName } from '../enums/LightName.js'; +import { RGBColor } from './RGBColor.js'; + +class LightState extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {LightName} id - The name of a light or a group of lights. + * @return {LightState} + */ + setId (id) { + this.validateType(LightName, id); + this.setParameter(LightState.KEY_ID, id); + return this; + } + + /** + * @return {LightName} + */ + getId () { + return this.getObject(LightName, LightState.KEY_ID); + } + + /** + * @param {LightStatus} status + * @return {LightState} + */ + setStatus (status) { + this.validateType(LightStatus, status); + this.setParameter(LightState.KEY_STATUS, status); + return this; + } + + /** + * @return {LightStatus} + */ + getStatus () { + return this.getObject(LightStatus, LightState.KEY_STATUS); + } + + /** + * @param {Number} density + * @return {LightState} + */ + setDensity (density) { + this.setParameter(LightState.KEY_DENSITY, density); + return this; + } + + /** + * @return {Number} + */ + getDensity () { + return this.getParameter(LightState.KEY_DENSITY); + } + + /** + * @param {RGBColor} color + * @return {LightState} + */ + setColor (color) { + this.validateType(RGBColor, color); + this.setParameter(LightState.KEY_COLOR, color); + return this; + } + + /** + * @return {RGBColor} + */ + getColor () { + return this.getObject(RGBColor, LightState.KEY_COLOR); + } +} + +LightState.KEY_ID = 'id'; +LightState.KEY_STATUS = 'status'; +LightState.KEY_DENSITY = 'density'; +LightState.KEY_COLOR = 'color'; + +export { LightState }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/LocationDetails.js b/lib/js/src/rpc/structs/LocationDetails.js new file mode 100644 index 00000000..0b5a368e --- /dev/null +++ b/lib/js/src/rpc/structs/LocationDetails.js @@ -0,0 +1,171 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Coordinate } from './Coordinate.js'; +import { Image } from './Image.js'; +import { OASISAddress } from './OASISAddress.js'; +import { RpcStruct } from '../RpcStruct.js'; + +class LocationDetails extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Coordinate} coordinate - Latitude/Longitude of the location. + * @return {LocationDetails} + */ + setCoordinate (coordinate) { + this.validateType(Coordinate, coordinate); + this.setParameter(LocationDetails.KEY_COORDINATE, coordinate); + return this; + } + + /** + * @return {Coordinate} + */ + getCoordinate () { + return this.getObject(Coordinate, LocationDetails.KEY_COORDINATE); + } + + /** + * @param {String} name - Name of location. + * @return {LocationDetails} + */ + setLocationName (name) { + this.setParameter(LocationDetails.KEY_LOCATION_NAME, name); + return this; + } + + /** + * @return {String} + */ + getLocationName () { + return this.getParameter(LocationDetails.KEY_LOCATION_NAME); + } + + /** + * @param {String[]} lines - Location address for display purposes only + * @return {LocationDetails} + */ + setAddressLines (lines) { + this.setParameter(LocationDetails.KEY_ADDRESS_LINES, lines); + return this; + } + + /** + * @return {String[]} + */ + getAddressLines () { + return this.getParameter(LocationDetails.KEY_ADDRESS_LINES); + } + + /** + * @param {String} description - Description intended location / establishment (if applicable) + * @return {LocationDetails} + */ + setLocationDescription (description) { + this.setParameter(LocationDetails.KEY_LOCATION_DESCRIPTION, description); + return this; + } + + /** + * @return {String} + */ + getLocationDescription () { + return this.getParameter(LocationDetails.KEY_LOCATION_DESCRIPTION); + } + + /** + * @param {String} number - Phone number of location / establishment. + * @return {LocationDetails} + */ + setPhoneNumber (number) { + this.setParameter(LocationDetails.KEY_PHONE_NUMBER, number); + return this; + } + + /** + * @return {String} + */ + getPhoneNumber () { + return this.getParameter(LocationDetails.KEY_PHONE_NUMBER); + } + + /** + * @param {Image} image - Image / icon of intended location. + * @return {LocationDetails} + */ + setLocationImage (image) { + this.validateType(Image, image); + this.setParameter(LocationDetails.KEY_LOCATION_IMAGE, image); + return this; + } + + /** + * @return {Image} + */ + getLocationImage () { + return this.getObject(Image, LocationDetails.KEY_LOCATION_IMAGE); + } + + /** + * @param {OASISAddress} address - Address to be used by navigation engines for search + * @return {LocationDetails} + */ + setSearchAddress (address) { + this.validateType(OASISAddress, address); + this.setParameter(LocationDetails.KEY_SEARCH_ADDRESS, address); + return this; + } + + /** + * @return {OASISAddress} + */ + getSearchAddress () { + return this.getObject(OASISAddress, LocationDetails.KEY_SEARCH_ADDRESS); + } +} + +LocationDetails.KEY_COORDINATE = 'coordinate'; +LocationDetails.KEY_LOCATION_NAME = 'locationName'; +LocationDetails.KEY_ADDRESS_LINES = 'addressLines'; +LocationDetails.KEY_LOCATION_DESCRIPTION = 'locationDescription'; +LocationDetails.KEY_PHONE_NUMBER = 'phoneNumber'; +LocationDetails.KEY_LOCATION_IMAGE = 'locationImage'; +LocationDetails.KEY_SEARCH_ADDRESS = 'searchAddress'; + +export { LocationDetails }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/MassageCushionFirmness.js b/lib/js/src/rpc/structs/MassageCushionFirmness.js new file mode 100644 index 00000000..98424231 --- /dev/null +++ b/lib/js/src/rpc/structs/MassageCushionFirmness.js @@ -0,0 +1,85 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { MassageCushion } from '../enums/MassageCushion.js'; + +/** + * The intensity or firmness of a cushion. + */ +class MassageCushionFirmness extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {MassageCushion} cushion - List possible cushions of a multi-contour massage seat. + * @return {MassageCushionFirmness} + */ + setCushion (cushion) { + this.validateType(MassageCushion, cushion); + this.setParameter(MassageCushionFirmness.KEY_CUSHION, cushion); + return this; + } + + /** + * @return {MassageCushion} + */ + getCushion () { + return this.getObject(MassageCushion, MassageCushionFirmness.KEY_CUSHION); + } + + /** + * @param {Number} firmness + * @return {MassageCushionFirmness} + */ + setFirmness (firmness) { + this.setParameter(MassageCushionFirmness.KEY_FIRMNESS, firmness); + return this; + } + + /** + * @return {Number} + */ + getFirmness () { + return this.getParameter(MassageCushionFirmness.KEY_FIRMNESS); + } +} + +MassageCushionFirmness.KEY_CUSHION = 'cushion'; +MassageCushionFirmness.KEY_FIRMNESS = 'firmness'; + +export { MassageCushionFirmness }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/MassageModeData.js b/lib/js/src/rpc/structs/MassageModeData.js new file mode 100644 index 00000000..681f9d96 --- /dev/null +++ b/lib/js/src/rpc/structs/MassageModeData.js @@ -0,0 +1,87 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { MassageZone } from '../enums/MassageZone.js'; +import { MassageMode } from '../enums/MassageMode.js'; + +/** + * Specify the mode of a massage zone. + */ +class MassageModeData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {MassageZone} zone - List possible zones of a multi-contour massage seat. + * @return {MassageModeData} + */ + setMassageZone (zone) { + this.validateType(MassageZone, zone); + this.setParameter(MassageModeData.KEY_MASSAGE_ZONE, zone); + return this; + } + + /** + * @return {MassageZone} + */ + getMassageZone () { + return this.getObject(MassageZone, MassageModeData.KEY_MASSAGE_ZONE); + } + + /** + * @param {MassageMode} mode - List possible modes of a massage zone. + * @return {MassageModeData} + */ + setMassageMode (mode) { + this.validateType(MassageMode, mode); + this.setParameter(MassageModeData.KEY_MASSAGE_MODE, mode); + return this; + } + + /** + * @return {MassageMode} + */ + getMassageMode () { + return this.getObject(MassageMode, MassageModeData.KEY_MASSAGE_MODE); + } +} + +MassageModeData.KEY_MASSAGE_ZONE = 'massageZone'; +MassageModeData.KEY_MASSAGE_MODE = 'massageMode'; + +export { MassageModeData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/MediaServiceData.js b/lib/js/src/rpc/structs/MediaServiceData.js new file mode 100644 index 00000000..0e3a0b75 --- /dev/null +++ b/lib/js/src/rpc/structs/MediaServiceData.js @@ -0,0 +1,295 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { Image } from './Image.js'; +import { MediaType } from '../enums/MediaType.js'; + +/** + * This data is related to what a media service should provide + */ +class MediaServiceData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {MediaType} type - The type of the currently playing or paused track. + * @return {MediaServiceData} + */ + setMediaType (type) { + this.validateType(MediaType, type); + this.setParameter(MediaServiceData.KEY_MEDIA_TYPE, type); + return this; + } + + /** + * @return {MediaType} + */ + getMediaType () { + return this.getObject(MediaType, MediaServiceData.KEY_MEDIA_TYPE); + } + + /** + * @param {String} title - Music: The name of the current track Podcast: The name of the current episode Audiobook: + * The name of the current chapter + * @return {MediaServiceData} + */ + setMediaTitle (title) { + this.setParameter(MediaServiceData.KEY_MEDIA_TITLE, title); + return this; + } + + /** + * @return {String} + */ + getMediaTitle () { + return this.getParameter(MediaServiceData.KEY_MEDIA_TITLE); + } + + /** + * @param {String} artist - Music: The name of the current album artist Podcast: The provider of the podcast (hosts, + * network, company) Audiobook: The book author's name + * @return {MediaServiceData} + */ + setMediaArtist (artist) { + this.setParameter(MediaServiceData.KEY_MEDIA_ARTIST, artist); + return this; + } + + /** + * @return {String} + */ + getMediaArtist () { + return this.getParameter(MediaServiceData.KEY_MEDIA_ARTIST); + } + + /** + * @param {String} album - Music: The name of the current album Podcast: The name of the current podcast show + * Audiobook: The name of the current book + * @return {MediaServiceData} + */ + setMediaAlbum (album) { + this.setParameter(MediaServiceData.KEY_MEDIA_ALBUM, album); + return this; + } + + /** + * @return {String} + */ + getMediaAlbum () { + return this.getParameter(MediaServiceData.KEY_MEDIA_ALBUM); + } + + /** + * @param {String} name - Music: The name of the playlist or radio station, if the user is playing from a playlist, + * otherwise, Null Podcast: The name of the playlist, if the user is playing from a playlist, + * otherwise, Null Audiobook: Likely not applicable, possibly a collection or "playlist" of + * books + * @return {MediaServiceData} + */ + setPlaylistName (name) { + this.setParameter(MediaServiceData.KEY_PLAYLIST_NAME, name); + return this; + } + + /** + * @return {String} + */ + getPlaylistName () { + return this.getParameter(MediaServiceData.KEY_PLAYLIST_NAME); + } + + /** + * @param {Boolean} explicit - Whether or not the content currently playing (e.g. the track, episode, or book) + * contains explicit content + * @return {MediaServiceData} + */ + setIsExplicit (explicit) { + this.setParameter(MediaServiceData.KEY_IS_EXPLICIT, explicit); + return this; + } + + /** + * @return {Boolean} + */ + getIsExplicit () { + return this.getParameter(MediaServiceData.KEY_IS_EXPLICIT); + } + + /** + * @param {Number} progress - Music: The current progress of the track in seconds Podcast: The current progress of + * the episode in seconds Audiobook: The current progress of the current segment (e.g. + * the chapter) in seconds + * @return {MediaServiceData} + */ + setTrackPlaybackProgress (progress) { + this.setParameter(MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS, progress); + return this; + } + + /** + * @return {Number} + */ + getTrackPlaybackProgress () { + return this.getParameter(MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS); + } + + /** + * @param {Number} duration - Music: The total duration of the track in seconds Podcast: The total duration of the + * episode in seconds Audiobook: The total duration of the current segment (e.g. the + * chapter) in seconds + * @return {MediaServiceData} + */ + setTrackPlaybackDuration (duration) { + this.setParameter(MediaServiceData.KEY_TRACK_PLAYBACK_DURATION, duration); + return this; + } + + /** + * @return {Number} + */ + getTrackPlaybackDuration () { + return this.getParameter(MediaServiceData.KEY_TRACK_PLAYBACK_DURATION); + } + + /** + * @param {Number} progress - Music: The current progress of the playback queue in seconds Podcast: The current + * progress of the playback queue in seconds Audiobook: The current progress of the + * playback queue (e.g. the book) in seconds + * @return {MediaServiceData} + */ + setQueuePlaybackProgress (progress) { + this.setParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS, progress); + return this; + } + + /** + * @return {Number} + */ + getQueuePlaybackProgress () { + return this.getParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS); + } + + /** + * @param {Number} duration - Music: The total duration of the playback queue in seconds Podcast: The total duration + * of the playback queue in seconds Audiobook: The total duration of the playback queue + * (e.g. the book) in seconds + * @return {MediaServiceData} + */ + setQueuePlaybackDuration (duration) { + this.setParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION, duration); + return this; + } + + /** + * @return {Number} + */ + getQueuePlaybackDuration () { + return this.getParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION); + } + + /** + * @param {Number} number - Music: The current number (1 based) of the track in the playback queue Podcast: The + * current number (1 based) of the episode in the playback queue Audiobook: The current + * number (1 based) of the episode in the playback queue (e.g. the chapter number in the + * book) + * @return {MediaServiceData} + */ + setQueueCurrentTrackNumber (number) { + this.setParameter(MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER, number); + return this; + } + + /** + * @return {Number} + */ + getQueueCurrentTrackNumber () { + return this.getParameter(MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER); + } + + /** + * @param {Number} count - Music: The total number of tracks in the playback queue Podcast: The total number of + * episodes in the playback queue Audiobook: The total number of sections in the playback + * queue (e.g. the number of chapters in the book) + * @return {MediaServiceData} + */ + setQueueTotalTrackCount (count) { + this.setParameter(MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT, count); + return this; + } + + /** + * @return {Number} + */ + getQueueTotalTrackCount () { + return this.getParameter(MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT); + } + + /** + * @param {Image} image - Music: The album art of the current track Podcast: The podcast or chapter artwork of the + * current podcast episode Audiobook: The book or chapter artwork of the current audiobook + * @return {MediaServiceData} + */ + setMediaImage (image) { + this.validateType(Image, image); + this.setParameter(MediaServiceData.KEY_MEDIA_IMAGE, image); + return this; + } + + /** + * @return {Image} + */ + getMediaImage () { + return this.getObject(Image, MediaServiceData.KEY_MEDIA_IMAGE); + } +} + +MediaServiceData.KEY_MEDIA_TYPE = 'mediaType'; +MediaServiceData.KEY_MEDIA_TITLE = 'mediaTitle'; +MediaServiceData.KEY_MEDIA_ARTIST = 'mediaArtist'; +MediaServiceData.KEY_MEDIA_ALBUM = 'mediaAlbum'; +MediaServiceData.KEY_PLAYLIST_NAME = 'playlistName'; +MediaServiceData.KEY_IS_EXPLICIT = 'isExplicit'; +MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS = 'trackPlaybackProgress'; +MediaServiceData.KEY_TRACK_PLAYBACK_DURATION = 'trackPlaybackDuration'; +MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS = 'queuePlaybackProgress'; +MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION = 'queuePlaybackDuration'; +MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER = 'queueCurrentTrackNumber'; +MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT = 'queueTotalTrackCount'; +MediaServiceData.KEY_MEDIA_IMAGE = 'mediaImage'; + +export { MediaServiceData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/MediaServiceManifest.js b/lib/js/src/rpc/structs/MediaServiceManifest.js new file mode 100644 index 00000000..5d12776e --- /dev/null +++ b/lib/js/src/rpc/structs/MediaServiceManifest.js @@ -0,0 +1,46 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class MediaServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } +} + + +export { MediaServiceManifest }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/MenuParams.js b/lib/js/src/rpc/structs/MenuParams.js index 17a89187..fe68f6fc 100644 --- a/lib/js/src/rpc/structs/MenuParams.js +++ b/lib/js/src/rpc/structs/MenuParams.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -34,63 +35,67 @@ import { RpcStruct } from '../RpcStruct.js'; class MenuParams extends RpcStruct { /** - * @constructor - */ + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Number} id - * @return {MenuParams} - */ + * @param {Number} id - unique ID of the sub menu, the command will be added to. If not provided, it will be + * provided to the top level of the in application menu. + * @return {MenuParams} + */ setParentID (id) { this.setParameter(MenuParams.KEY_PARENT_ID, id); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getParentID () { return this.getParameter(MenuParams.KEY_PARENT_ID); } /** - * @param {Number} position - * @return {MenuParams} - */ + * @param {Number} position - Position within the items that are are at top level of the in application menu. 0 will + * insert at the front. 1 will insert at the second position. if position is greater or + * equal than the number of items on top level, the sub menu will be appended to the end. + * If this param was omitted the entry will be added at the end. + * @return {MenuParams} + */ setPosition (position) { this.setParameter(MenuParams.KEY_POSITION, position); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getPosition () { return this.getParameter(MenuParams.KEY_POSITION); } /** - * @param {String} menuName - * @return {MenuParams} - */ - setMenuName (menuName) { - this.setParameter(MenuParams.KEY_MENU_NAME, menuName); + * @param {String} name - Text to show in the menu for this sub menu. + * @return {MenuParams} + */ + setMenuName (name) { + this.setParameter(MenuParams.KEY_MENU_NAME, name); return this; } /** - * @param {String} - */ + * @return {String} + */ getMenuName () { return this.getParameter(MenuParams.KEY_MENU_NAME); } } MenuParams.KEY_PARENT_ID = 'parentID'; -MenuParams.KEY_POSITION = 'position'; +MenuParams.KEY_POSITION = 'position'; MenuParams.KEY_MENU_NAME = 'menuName'; -export { MenuParams }; +export { MenuParams }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/MetadataTags.js b/lib/js/src/rpc/structs/MetadataTags.js index 66bd7ea0..34a13d93 100644 --- a/lib/js/src/rpc/structs/MetadataTags.js +++ b/lib/js/src/rpc/structs/MetadataTags.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -35,72 +36,76 @@ import { MetadataType } from '../enums/MetadataType.js'; class MetadataTags extends RpcStruct { /** - * @constructor - */ + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Array} mainField1 - * @return {MetadataTags} - */ - setMainField1 (mainField1) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_1, mainField1); + * @param {MetadataType[]} field1 - The type of data contained in the "mainField1" text field. + * @return {MetadataTags} + */ + setMainField1 (field1) { + this.validateType(MetadataType, field1, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_1, field1); return this; } /** - * @return {Array} - */ + * @return {MetadataType[]} + */ getMainField1 () { return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_1); } /** - * @param {Array} mainField2 - * @return {MetadataTags} - */ - setMainField2 (mainField2) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_2, mainField2); + * @param {MetadataType[]} field2 - The type of data contained in the "mainField2" text field. + * @return {MetadataTags} + */ + setMainField2 (field2) { + this.validateType(MetadataType, field2, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_2, field2); return this; } /** - * @return {Array} - */ + * @return {MetadataType[]} + */ getMainField2 () { return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_2); } /** - * @param {Array} mainField3 - * @return {MetadataTags} - */ - setMainField3 (mainField3) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_3, mainField3); + * @param {MetadataType[]} field3 - The type of data contained in the "mainField3" text field. + * @return {MetadataTags} + */ + setMainField3 (field3) { + this.validateType(MetadataType, field3, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_3, field3); return this; } /** - * @return {Array} - */ + * @return {MetadataType[]} + */ getMainField3 () { return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_3); } /** - * @param {Array} mainField4 - * @return {MetadataTags} - */ - setMainField4 (mainField4) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_4, mainField4); + * @param {MetadataType[]} field4 - The type of data contained in the "mainField4" text field. + * @return {MetadataTags} + */ + setMainField4 (field4) { + this.validateType(MetadataType, field4, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_4, field4); return this; } /** - * @return {Array} - */ + * @return {MetadataType[]} + */ getMainField4 () { return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_4); } @@ -111,4 +116,4 @@ MetadataTags.KEY_MAIN_FIELD_2 = 'mainField2'; MetadataTags.KEY_MAIN_FIELD_3 = 'mainField3'; MetadataTags.KEY_MAIN_FIELD_4 = 'mainField4'; -export { MetadataTags }; +export { MetadataTags }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ModuleData.js b/lib/js/src/rpc/structs/ModuleData.js new file mode 100644 index 00000000..4ac7f92d --- /dev/null +++ b/lib/js/src/rpc/structs/ModuleData.js @@ -0,0 +1,200 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { HMISettingsControlData } from './HMISettingsControlData.js'; +import { RadioControlData } from './RadioControlData.js'; +import { ModuleType } from '../enums/ModuleType.js'; +import { ClimateControlData } from './ClimateControlData.js'; +import { AudioControlData } from './AudioControlData.js'; +import { SeatControlData } from './SeatControlData.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { LightControlData } from './LightControlData.js'; + +/** + * The moduleType indicates which type of data should be changed and identifies which data object exists in this + * struct. For example, if the moduleType is CLIMATE then a "climateControlData" should exist + */ +class ModuleData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {ModuleType} type + * @return {ModuleData} + */ + setModuleType (type) { + this.validateType(ModuleType, type); + this.setParameter(ModuleData.KEY_MODULE_TYPE, type); + return this; + } + + /** + * @return {ModuleType} + */ + getModuleType () { + return this.getObject(ModuleType, ModuleData.KEY_MODULE_TYPE); + } + + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {ModuleData} + */ + setModuleId (id) { + this.setParameter(ModuleData.KEY_MODULE_ID, id); + return this; + } + + /** + * @return {String} + */ + getModuleId () { + return this.getParameter(ModuleData.KEY_MODULE_ID); + } + + /** + * @param {RadioControlData} data + * @return {ModuleData} + */ + setRadioControlData (data) { + this.validateType(RadioControlData, data); + this.setParameter(ModuleData.KEY_RADIO_CONTROL_DATA, data); + return this; + } + + /** + * @return {RadioControlData} + */ + getRadioControlData () { + return this.getObject(RadioControlData, ModuleData.KEY_RADIO_CONTROL_DATA); + } + + /** + * @param {ClimateControlData} data + * @return {ModuleData} + */ + setClimateControlData (data) { + this.validateType(ClimateControlData, data); + this.setParameter(ModuleData.KEY_CLIMATE_CONTROL_DATA, data); + return this; + } + + /** + * @return {ClimateControlData} + */ + getClimateControlData () { + return this.getObject(ClimateControlData, ModuleData.KEY_CLIMATE_CONTROL_DATA); + } + + /** + * @param {SeatControlData} data - Seat control data corresponds to "SEAT" ModuleType. + * @return {ModuleData} + */ + setSeatControlData (data) { + this.validateType(SeatControlData, data); + this.setParameter(ModuleData.KEY_SEAT_CONTROL_DATA, data); + return this; + } + + /** + * @return {SeatControlData} + */ + getSeatControlData () { + return this.getObject(SeatControlData, ModuleData.KEY_SEAT_CONTROL_DATA); + } + + /** + * @param {AudioControlData} data + * @return {ModuleData} + */ + setAudioControlData (data) { + this.validateType(AudioControlData, data); + this.setParameter(ModuleData.KEY_AUDIO_CONTROL_DATA, data); + return this; + } + + /** + * @return {AudioControlData} + */ + getAudioControlData () { + return this.getObject(AudioControlData, ModuleData.KEY_AUDIO_CONTROL_DATA); + } + + /** + * @param {LightControlData} data + * @return {ModuleData} + */ + setLightControlData (data) { + this.validateType(LightControlData, data); + this.setParameter(ModuleData.KEY_LIGHT_CONTROL_DATA, data); + return this; + } + + /** + * @return {LightControlData} + */ + getLightControlData () { + return this.getObject(LightControlData, ModuleData.KEY_LIGHT_CONTROL_DATA); + } + + /** + * @param {HMISettingsControlData} data - Corresponds to "HMI_SETTINGS" ModuleType + * @return {ModuleData} + */ + setHmiSettingsControlData (data) { + this.validateType(HMISettingsControlData, data); + this.setParameter(ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA, data); + return this; + } + + /** + * @return {HMISettingsControlData} + */ + getHmiSettingsControlData () { + return this.getObject(HMISettingsControlData, ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA); + } +} + +ModuleData.KEY_MODULE_TYPE = 'moduleType'; +ModuleData.KEY_MODULE_ID = 'moduleId'; +ModuleData.KEY_RADIO_CONTROL_DATA = 'radioControlData'; +ModuleData.KEY_CLIMATE_CONTROL_DATA = 'climateControlData'; +ModuleData.KEY_SEAT_CONTROL_DATA = 'seatControlData'; +ModuleData.KEY_AUDIO_CONTROL_DATA = 'audioControlData'; +ModuleData.KEY_LIGHT_CONTROL_DATA = 'lightControlData'; +ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA = 'hmiSettingsControlData'; + +export { ModuleData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ModuleInfo.js b/lib/js/src/rpc/structs/ModuleInfo.js index 692b2d0f..7817315c 100644 --- a/lib/js/src/rpc/structs/ModuleInfo.js +++ b/lib/js/src/rpc/structs/ModuleInfo.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,76 +34,79 @@ import { RpcStruct } from '../RpcStruct.js'; import { Grid } from './Grid.js'; +/** + * Information about a RC module + */ class ModuleInfo extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {String} moduleId - * @return {ModuleInfo} - */ - setModuleId (moduleId) { - this.setParameter(ModuleInfo.KEY_MODULE_ID, moduleId); + * @param {String} id - uuid of a module. "moduleId + moduleType" uniquely identify a module. + * @return {ModuleInfo} + */ + setModuleId (id) { + this.setParameter(ModuleInfo.KEY_MODULE_ID, id); return this; } /** - * @return {String} - */ + * @return {String} + */ getModuleId () { return this.getParameter(ModuleInfo.KEY_MODULE_ID); } - /** - * @param {Grid} location - * @return {ModuleInfo} - */ + * @param {Grid} location - Location of a module. + * @return {ModuleInfo} + */ setLocation (location) { this.validateType(Grid, location); - this.setParameter(ModuleInfo.KEY_LOCATION, location); return this; } /** - * @return {Grid} - */ + * @return {Grid} + */ getLocation () { return this.getObject(Grid, ModuleInfo.KEY_LOCATION); } /** - * @param {Grid} serviceArea - * @return {ModuleInfo} - */ - setServiceArea (serviceArea) { - this.validateType(Grid, serviceArea); - - this.setParameter(ModuleInfo.KEY_SERVICE_AREA, serviceArea); + * @param {Grid} area - Service area of a module. + * @return {ModuleInfo} + */ + setServiceArea (area) { + this.validateType(Grid, area); + this.setParameter(ModuleInfo.KEY_SERVICE_AREA, area); return this; } /** - * @return {Grid} - */ + * @return {Grid} + */ getServiceArea () { return this.getObject(Grid, ModuleInfo.KEY_SERVICE_AREA); } /** - * @param {Boolean} allowMultipleAccess - * @return {ModuleInfo} - */ - setAllowMultipleAccess (allowMultipleAccess) { - this.setParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS, allowMultipleAccess); + * @param {Boolean} access - allow multiple users/apps to access the module or not + * @return {ModuleInfo} + */ + setAllowMultipleAccess (access) { + this.setParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS, access); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getAllowMultipleAccess () { return this.getParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS); } @@ -113,4 +117,4 @@ ModuleInfo.KEY_LOCATION = 'location'; ModuleInfo.KEY_SERVICE_AREA = 'serviceArea'; ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS = 'allowMultipleAccess'; -export { ModuleInfo }; +export { ModuleInfo }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/MyKey.js b/lib/js/src/rpc/structs/MyKey.js new file mode 100644 index 00000000..de0069bf --- /dev/null +++ b/lib/js/src/rpc/structs/MyKey.js @@ -0,0 +1,66 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { VehicleDataStatus } from '../enums/VehicleDataStatus.js'; + +class MyKey extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {VehicleDataStatus} e911override - Indicates whether e911 override is on. References signal + * "MyKey_e911Override_St". See VehicleDataStatus. + * @return {MyKey} + */ + setE911Override (e911override) { + this.validateType(VehicleDataStatus, e911override); + this.setParameter(MyKey.KEY_E911OVERRIDE, e911override); + return this; + } + + /** + * @return {VehicleDataStatus} + */ + getE911Override () { + return this.getObject(VehicleDataStatus, MyKey.KEY_E911OVERRIDE); + } +} + +MyKey.KEY_E911OVERRIDE = 'e911Override'; + +export { MyKey }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/NavigationCapability.js b/lib/js/src/rpc/structs/NavigationCapability.js new file mode 100644 index 00000000..5051abdf --- /dev/null +++ b/lib/js/src/rpc/structs/NavigationCapability.js @@ -0,0 +1,83 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +/** + * Extended capabilities for an onboard navigation system + */ +class NavigationCapability extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} enabled - If the module has the ability to add locations to the onboard nav + * @return {NavigationCapability} + */ + setSendLocationEnabled (enabled) { + this.setParameter(NavigationCapability.KEY_SEND_LOCATION_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getSendLocationEnabled () { + return this.getParameter(NavigationCapability.KEY_SEND_LOCATION_ENABLED); + } + + /** + * @param {Boolean} enabled - If the module has the ability to return way points from onboard nav + * @return {NavigationCapability} + */ + setGetWayPointsEnabled (enabled) { + this.setParameter(NavigationCapability.KEY_GET_WAY_POINTS_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getGetWayPointsEnabled () { + return this.getParameter(NavigationCapability.KEY_GET_WAY_POINTS_ENABLED); + } +} + +NavigationCapability.KEY_SEND_LOCATION_ENABLED = 'sendLocationEnabled'; +NavigationCapability.KEY_GET_WAY_POINTS_ENABLED = 'getWayPointsEnabled'; + +export { NavigationCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/NavigationInstruction.js b/lib/js/src/rpc/structs/NavigationInstruction.js new file mode 100644 index 00000000..aba2eaf8 --- /dev/null +++ b/lib/js/src/rpc/structs/NavigationInstruction.js @@ -0,0 +1,200 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Image } from './Image.js'; +import { DateTime } from './DateTime.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { NavigationJunction } from '../enums/NavigationJunction.js'; +import { Direction } from '../enums/Direction.js'; +import { LocationDetails } from './LocationDetails.js'; +import { NavigationAction } from '../enums/NavigationAction.js'; + +class NavigationInstruction extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {LocationDetails} details + * @return {NavigationInstruction} + */ + setLocationDetails (details) { + this.validateType(LocationDetails, details); + this.setParameter(NavigationInstruction.KEY_LOCATION_DETAILS, details); + return this; + } + + /** + * @return {LocationDetails} + */ + getLocationDetails () { + return this.getObject(LocationDetails, NavigationInstruction.KEY_LOCATION_DETAILS); + } + + /** + * @param {NavigationAction} action + * @return {NavigationInstruction} + */ + setAction (action) { + this.validateType(NavigationAction, action); + this.setParameter(NavigationInstruction.KEY_ACTION, action); + return this; + } + + /** + * @return {NavigationAction} + */ + getAction () { + return this.getObject(NavigationAction, NavigationInstruction.KEY_ACTION); + } + + /** + * @param {DateTime} eta + * @return {NavigationInstruction} + */ + setEta (eta) { + this.validateType(DateTime, eta); + this.setParameter(NavigationInstruction.KEY_ETA, eta); + return this; + } + + /** + * @return {DateTime} + */ + getEta () { + return this.getObject(DateTime, NavigationInstruction.KEY_ETA); + } + + /** + * @param {Number} bearing - The angle at which this instruction takes place. For example, 0 would mean straight, + * less than 45 is bearing right, greater than 135 is sharp right, between 45 and 135 is a + * regular right, and 180 is a U-Turn, etc. + * @return {NavigationInstruction} + */ + setBearing (bearing) { + this.setParameter(NavigationInstruction.KEY_BEARING, bearing); + return this; + } + + /** + * @return {Number} + */ + getBearing () { + return this.getParameter(NavigationInstruction.KEY_BEARING); + } + + /** + * @param {NavigationJunction} type + * @return {NavigationInstruction} + */ + setJunctionType (type) { + this.validateType(NavigationJunction, type); + this.setParameter(NavigationInstruction.KEY_JUNCTION_TYPE, type); + return this; + } + + /** + * @return {NavigationJunction} + */ + getJunctionType () { + return this.getObject(NavigationJunction, NavigationInstruction.KEY_JUNCTION_TYPE); + } + + /** + * @param {Direction} side - Used to infer which side of the road this instruction takes place. For a U-Turn + * (action=TURN, bearing=180) this will determine which direction the turn should take + * place. + * @return {NavigationInstruction} + */ + setDrivingSide (side) { + this.validateType(Direction, side); + this.setParameter(NavigationInstruction.KEY_DRIVING_SIDE, side); + return this; + } + + /** + * @return {Direction} + */ + getDrivingSide () { + return this.getObject(Direction, NavigationInstruction.KEY_DRIVING_SIDE); + } + + /** + * @param {String} details - This is a string representation of this instruction, used to display instructions to + * the users. This is not intended to be read aloud to the users, see the param prompt in + * NavigationServiceData for that. + * @return {NavigationInstruction} + */ + setDetails (details) { + this.setParameter(NavigationInstruction.KEY_DETAILS, details); + return this; + } + + /** + * @return {String} + */ + getDetails () { + return this.getParameter(NavigationInstruction.KEY_DETAILS); + } + + /** + * @param {Image} image - An image representation of this instruction. + * @return {NavigationInstruction} + */ + setImage (image) { + this.validateType(Image, image); + this.setParameter(NavigationInstruction.KEY_IMAGE, image); + return this; + } + + /** + * @return {Image} + */ + getImage () { + return this.getObject(Image, NavigationInstruction.KEY_IMAGE); + } +} + +NavigationInstruction.KEY_LOCATION_DETAILS = 'locationDetails'; +NavigationInstruction.KEY_ACTION = 'action'; +NavigationInstruction.KEY_ETA = 'eta'; +NavigationInstruction.KEY_BEARING = 'bearing'; +NavigationInstruction.KEY_JUNCTION_TYPE = 'junctionType'; +NavigationInstruction.KEY_DRIVING_SIDE = 'drivingSide'; +NavigationInstruction.KEY_DETAILS = 'details'; +NavigationInstruction.KEY_IMAGE = 'image'; + +export { NavigationInstruction }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/NavigationServiceData.js b/lib/js/src/rpc/structs/NavigationServiceData.js new file mode 100644 index 00000000..1046e16a --- /dev/null +++ b/lib/js/src/rpc/structs/NavigationServiceData.js @@ -0,0 +1,218 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { DateTime } from './DateTime.js'; +import { LocationDetails } from './LocationDetails.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { NavigationInstruction } from './NavigationInstruction.js'; + +/** + * This data is related to what a navigation service would provide. + */ +class NavigationServiceData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {DateTime} stamp - This is the timestamp of when the data was generated. This is to ensure any time or + * distance given in the data can accurately be adjusted if necessary. + * @return {NavigationServiceData} + */ + setTimeStamp (stamp) { + this.validateType(DateTime, stamp); + this.setParameter(NavigationServiceData.KEY_TIME_STAMP, stamp); + return this; + } + + /** + * @return {DateTime} + */ + getTimeStamp () { + return this.getObject(DateTime, NavigationServiceData.KEY_TIME_STAMP); + } + + /** + * @param {LocationDetails} origin + * @return {NavigationServiceData} + */ + setOrigin (origin) { + this.validateType(LocationDetails, origin); + this.setParameter(NavigationServiceData.KEY_ORIGIN, origin); + return this; + } + + /** + * @return {LocationDetails} + */ + getOrigin () { + return this.getObject(LocationDetails, NavigationServiceData.KEY_ORIGIN); + } + + /** + * @param {LocationDetails} destination + * @return {NavigationServiceData} + */ + setDestination (destination) { + this.validateType(LocationDetails, destination); + this.setParameter(NavigationServiceData.KEY_DESTINATION, destination); + return this; + } + + /** + * @return {LocationDetails} + */ + getDestination () { + return this.getObject(LocationDetails, NavigationServiceData.KEY_DESTINATION); + } + + /** + * @param {DateTime} eta + * @return {NavigationServiceData} + */ + setDestinationETA (eta) { + this.validateType(DateTime, eta); + this.setParameter(NavigationServiceData.KEY_DESTINATION_ETA, eta); + return this; + } + + /** + * @return {DateTime} + */ + getDestinationETA () { + return this.getObject(DateTime, NavigationServiceData.KEY_DESTINATION_ETA); + } + + /** + * @param {NavigationInstruction[]} instructions - This array should be ordered with all remaining instructions. The + * start of this array should always contain the next instruction. + * @return {NavigationServiceData} + */ + setInstructions (instructions) { + this.validateType(NavigationInstruction, instructions, true); + this.setParameter(NavigationServiceData.KEY_INSTRUCTIONS, instructions); + return this; + } + + /** + * @return {NavigationInstruction[]} + */ + getInstructions () { + return this.getObject(NavigationInstruction, NavigationServiceData.KEY_INSTRUCTIONS); + } + + /** + * @param {DateTime} eta + * @return {NavigationServiceData} + */ + setNextInstructionETA (eta) { + this.validateType(DateTime, eta); + this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA, eta); + return this; + } + + /** + * @return {DateTime} + */ + getNextInstructionETA () { + return this.getObject(DateTime, NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA); + } + + /** + * @param {Number} distance - The distance to this instruction from current location. This should only be updated + * ever .1 unit of distance. For more accuracy the consumer can use the GPS location of + * itself and the next instruction. + * @return {NavigationServiceData} + */ + setNextInstructionDistance (distance) { + this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE, distance); + return this; + } + + /** + * @return {Number} + */ + getNextInstructionDistance () { + return this.getParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE); + } + + /** + * @param {Number} scale - Distance till next maneuver (starting from) from previous maneuver. + * @return {NavigationServiceData} + */ + setNextInstructionDistanceScale (scale) { + this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE, scale); + return this; + } + + /** + * @return {Number} + */ + getNextInstructionDistanceScale () { + return this.getParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE); + } + + /** + * @param {String} prompt - This is a prompt message that should be conveyed to the user through either display or + * voice (TTS). This param will change often as it should represent the following: + * approaching instruction, post instruction, alerts that affect the current navigation + * session, etc. + * @return {NavigationServiceData} + */ + setPrompt (prompt) { + this.setParameter(NavigationServiceData.KEY_PROMPT, prompt); + return this; + } + + /** + * @return {String} + */ + getPrompt () { + return this.getParameter(NavigationServiceData.KEY_PROMPT); + } +} + +NavigationServiceData.KEY_TIME_STAMP = 'timeStamp'; +NavigationServiceData.KEY_ORIGIN = 'origin'; +NavigationServiceData.KEY_DESTINATION = 'destination'; +NavigationServiceData.KEY_DESTINATION_ETA = 'destinationETA'; +NavigationServiceData.KEY_INSTRUCTIONS = 'instructions'; +NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA = 'nextInstructionETA'; +NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE = 'nextInstructionDistance'; +NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE = 'nextInstructionDistanceScale'; +NavigationServiceData.KEY_PROMPT = 'prompt'; + +export { NavigationServiceData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/NavigationServiceManifest.js b/lib/js/src/rpc/structs/NavigationServiceManifest.js new file mode 100644 index 00000000..31ceabb2 --- /dev/null +++ b/lib/js/src/rpc/structs/NavigationServiceManifest.js @@ -0,0 +1,63 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class NavigationServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} points - Informs the subscriber if this service can actually accept way points. + * @return {NavigationServiceManifest} + */ + setAcceptsWayPoints (points) { + this.setParameter(NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS, points); + return this; + } + + /** + * @return {Boolean} + */ + getAcceptsWayPoints () { + return this.getParameter(NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS); + } +} + +NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS = 'acceptsWayPoints'; + +export { NavigationServiceManifest }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/OASISAddress.js b/lib/js/src/rpc/structs/OASISAddress.js new file mode 100644 index 00000000..1bc522fa --- /dev/null +++ b/lib/js/src/rpc/structs/OASISAddress.js @@ -0,0 +1,199 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class OASISAddress extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - Name of the country (localized) + * @return {OASISAddress} + */ + setCountryName (name) { + this.setParameter(OASISAddress.KEY_COUNTRY_NAME, name); + return this; + } + + /** + * @return {String} + */ + getCountryName () { + return this.getParameter(OASISAddress.KEY_COUNTRY_NAME); + } + + /** + * @param {String} code - Name of country (ISO 3166-2) + * @return {OASISAddress} + */ + setCountryCode (code) { + this.setParameter(OASISAddress.KEY_COUNTRY_CODE, code); + return this; + } + + /** + * @return {String} + */ + getCountryCode () { + return this.getParameter(OASISAddress.KEY_COUNTRY_CODE); + } + + /** + * @param {String} code - (PLZ, ZIP, PIN, CAP etc.) + * @return {OASISAddress} + */ + setPostalCode (code) { + this.setParameter(OASISAddress.KEY_POSTAL_CODE, code); + return this; + } + + /** + * @return {String} + */ + getPostalCode () { + return this.getParameter(OASISAddress.KEY_POSTAL_CODE); + } + + /** + * @param {String} area - Portion of country (e.g. state) + * @return {OASISAddress} + */ + setAdministrativeArea (area) { + this.setParameter(OASISAddress.KEY_ADMINISTRATIVE_AREA, area); + return this; + } + + /** + * @return {String} + */ + getAdministrativeArea () { + return this.getParameter(OASISAddress.KEY_ADMINISTRATIVE_AREA); + } + + /** + * @param {String} area - Portion of e.g. state (e.g. county) + * @return {OASISAddress} + */ + setSubAdministrativeArea (area) { + this.setParameter(OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA, area); + return this; + } + + /** + * @return {String} + */ + getSubAdministrativeArea () { + return this.getParameter(OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA); + } + + /** + * @param {String} locality - Hypernym for e.g. city/village + * @return {OASISAddress} + */ + setLocality (locality) { + this.setParameter(OASISAddress.KEY_LOCALITY, locality); + return this; + } + + /** + * @return {String} + */ + getLocality () { + return this.getParameter(OASISAddress.KEY_LOCALITY); + } + + /** + * @param {String} locality - Hypernym for e.g. district + * @return {OASISAddress} + */ + setSubLocality (locality) { + this.setParameter(OASISAddress.KEY_SUB_LOCALITY, locality); + return this; + } + + /** + * @return {String} + */ + getSubLocality () { + return this.getParameter(OASISAddress.KEY_SUB_LOCALITY); + } + + /** + * @param {String} thoroughfare - Hypernym for street, road etc. + * @return {OASISAddress} + */ + setThoroughfare (thoroughfare) { + this.setParameter(OASISAddress.KEY_THOROUGHFARE, thoroughfare); + return this; + } + + /** + * @return {String} + */ + getThoroughfare () { + return this.getParameter(OASISAddress.KEY_THOROUGHFARE); + } + + /** + * @param {String} thoroughfare - Portion of thoroughfare e.g. house number + * @return {OASISAddress} + */ + setSubThoroughfare (thoroughfare) { + this.setParameter(OASISAddress.KEY_SUB_THOROUGHFARE, thoroughfare); + return this; + } + + /** + * @return {String} + */ + getSubThoroughfare () { + return this.getParameter(OASISAddress.KEY_SUB_THOROUGHFARE); + } +} + +OASISAddress.KEY_COUNTRY_NAME = 'countryName'; +OASISAddress.KEY_COUNTRY_CODE = 'countryCode'; +OASISAddress.KEY_POSTAL_CODE = 'postalCode'; +OASISAddress.KEY_ADMINISTRATIVE_AREA = 'administrativeArea'; +OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA = 'subAdministrativeArea'; +OASISAddress.KEY_LOCALITY = 'locality'; +OASISAddress.KEY_SUB_LOCALITY = 'subLocality'; +OASISAddress.KEY_THOROUGHFARE = 'thoroughfare'; +OASISAddress.KEY_SUB_THOROUGHFARE = 'subThoroughfare'; + +export { OASISAddress }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ParameterPermissions.js b/lib/js/src/rpc/structs/ParameterPermissions.js new file mode 100644 index 00000000..d2cfbd3d --- /dev/null +++ b/lib/js/src/rpc/structs/ParameterPermissions.js @@ -0,0 +1,80 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class ParameterPermissions extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String[]} allowed - A set of all parameters that are permitted for this given RPC. + * @return {ParameterPermissions} + */ + setAllowed (allowed) { + this.setParameter(ParameterPermissions.KEY_ALLOWED, allowed); + return this; + } + + /** + * @return {String[]} + */ + getAllowed () { + return this.getParameter(ParameterPermissions.KEY_ALLOWED); + } + + /** + * @param {String[]} disallowed - A set of all parameters that are prohibited for this given RPC. + * @return {ParameterPermissions} + */ + setUserDisallowed (disallowed) { + this.setParameter(ParameterPermissions.KEY_USER_DISALLOWED, disallowed); + return this; + } + + /** + * @return {String[]} + */ + getUserDisallowed () { + return this.getParameter(ParameterPermissions.KEY_USER_DISALLOWED); + } +} + +ParameterPermissions.KEY_ALLOWED = 'allowed'; +ParameterPermissions.KEY_USER_DISALLOWED = 'userDisallowed'; + +export { ParameterPermissions }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/PermissionItem.js b/lib/js/src/rpc/structs/PermissionItem.js new file mode 100644 index 00000000..999946c6 --- /dev/null +++ b/lib/js/src/rpc/structs/PermissionItem.js @@ -0,0 +1,118 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { HMIPermissions } from './HMIPermissions.js'; +import { ParameterPermissions } from './ParameterPermissions.js'; + +class PermissionItem extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - Name of the individual RPC in the policy table. + * @return {PermissionItem} + */ + setRpcName (name) { + this.setParameter(PermissionItem.KEY_RPC_NAME, name); + return this; + } + + /** + * @return {String} + */ + getRpcName () { + return this.getParameter(PermissionItem.KEY_RPC_NAME); + } + + /** + * @param {HMIPermissions} permissions + * @return {PermissionItem} + */ + setHmiPermissions (permissions) { + this.validateType(HMIPermissions, permissions); + this.setParameter(PermissionItem.KEY_HMI_PERMISSIONS, permissions); + return this; + } + + /** + * @return {HMIPermissions} + */ + getHmiPermissions () { + return this.getObject(HMIPermissions, PermissionItem.KEY_HMI_PERMISSIONS); + } + + /** + * @param {ParameterPermissions} permissions + * @return {PermissionItem} + */ + setParameterPermissions (permissions) { + this.validateType(ParameterPermissions, permissions); + this.setParameter(PermissionItem.KEY_PARAMETER_PERMISSIONS, permissions); + return this; + } + + /** + * @return {ParameterPermissions} + */ + getParameterPermissions () { + return this.getObject(ParameterPermissions, PermissionItem.KEY_PARAMETER_PERMISSIONS); + } + + /** + * @param {Boolean} encryption + * @return {PermissionItem} + */ + setRequireEncryption (encryption) { + this.setParameter(PermissionItem.KEY_REQUIRE_ENCRYPTION, encryption); + return this; + } + + /** + * @return {Boolean} + */ + getRequireEncryption () { + return this.getParameter(PermissionItem.KEY_REQUIRE_ENCRYPTION); + } +} + +PermissionItem.KEY_RPC_NAME = 'rpcName'; +PermissionItem.KEY_HMI_PERMISSIONS = 'hmiPermissions'; +PermissionItem.KEY_PARAMETER_PERMISSIONS = 'parameterPermissions'; +PermissionItem.KEY_REQUIRE_ENCRYPTION = 'requireEncryption'; + +export { PermissionItem }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/PhoneCapability.js b/lib/js/src/rpc/structs/PhoneCapability.js new file mode 100644 index 00000000..735e3ec1 --- /dev/null +++ b/lib/js/src/rpc/structs/PhoneCapability.js @@ -0,0 +1,66 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +/** + * Extended capabilities of the module's phone feature + */ +class PhoneCapability extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} enabled - If the module has the ability to perform dial number + * @return {PhoneCapability} + */ + setDialNumberEnabled (enabled) { + this.setParameter(PhoneCapability.KEY_DIAL_NUMBER_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getDialNumberEnabled () { + return this.getParameter(PhoneCapability.KEY_DIAL_NUMBER_ENABLED); + } +} + +PhoneCapability.KEY_DIAL_NUMBER_ENABLED = 'dialNumberEnabled'; + +export { PhoneCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/PresetBankCapabilities.js b/lib/js/src/rpc/structs/PresetBankCapabilities.js index 845793c5..c13a3940 100644 --- a/lib/js/src/rpc/structs/PresetBankCapabilities.js +++ b/lib/js/src/rpc/structs/PresetBankCapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,23 +33,29 @@ import { RpcStruct } from '../RpcStruct.js'; +/** + * Contains information about on-screen preset capabilities. + */ class PresetBankCapabilities extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Boolean} onScreenPresetsAvailable - * @return {PresetBankCapabilities} - */ - setOnScreenPresetsAvailable (onScreenPresetsAvailable) { - this.setParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE, onScreenPresetsAvailable); + * @param {Boolean} available - Onscreen custom presets are available. + * @return {PresetBankCapabilities} + */ + setOnScreenPresetsAvailable (available) { + this.setParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getOnScreenPresetsAvailable () { return this.getParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE); } @@ -56,4 +63,4 @@ class PresetBankCapabilities extends RpcStruct { PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE = 'onScreenPresetsAvailable'; -export { PresetBankCapabilities }; +export { PresetBankCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/RGBColor.js b/lib/js/src/rpc/structs/RGBColor.js index 2b4c9f94..a0d034f5 100644 --- a/lib/js/src/rpc/structs/RGBColor.js +++ b/lib/js/src/rpc/structs/RGBColor.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,57 +34,58 @@ import { RpcStruct } from '../RpcStruct.js'; class RGBColor extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Number} redValue - * @return {RGBColor} - */ - setRedValue (redValue) { - this.setParameter(RGBColor.KEY_RED, redValue); + * @param {Number} red + * @return {RGBColor} + */ + setRed (red) { + this.setParameter(RGBColor.KEY_RED, red); return this; } /** - * @return {Number} - */ - getRedValue () { + * @return {Number} + */ + getRed () { return this.getParameter(RGBColor.KEY_RED); } - /** - * @param {Number} greenValue - * @return {RGBColor} - */ - setGreenValue (greenValue) { - this.setParameter(RGBColor.KEY_GREEN, greenValue); + * @param {Number} green + * @return {RGBColor} + */ + setGreen (green) { + this.setParameter(RGBColor.KEY_GREEN, green); return this; } /** - * @return {Number} - */ - getGreenValue () { + * @return {Number} + */ + getGreen () { return this.getParameter(RGBColor.KEY_GREEN); } - /** - * @param {Number} blueValue - * @return {RGBColor} - */ - setBlueValue (blueValue) { - this.setParameter(RGBColor.KEY_BLUE, blueValue); + * @param {Number} blue + * @return {RGBColor} + */ + setBlue (blue) { + this.setParameter(RGBColor.KEY_BLUE, blue); return this; } /** - * @return {Number} - */ - getBlueValue () { + * @return {Number} + */ + getBlue () { return this.getParameter(RGBColor.KEY_BLUE); } } @@ -92,4 +94,4 @@ RGBColor.KEY_RED = 'red'; RGBColor.KEY_GREEN = 'green'; RGBColor.KEY_BLUE = 'blue'; -export { RGBColor }; +export { RGBColor }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/RadioControlCapabilities.js b/lib/js/src/rpc/structs/RadioControlCapabilities.js new file mode 100644 index 00000000..bd10ddd9 --- /dev/null +++ b/lib/js/src/rpc/structs/RadioControlCapabilities.js @@ -0,0 +1,320 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { ModuleInfo } from './ModuleInfo.js'; + +/** + * Contains information about a radio control module's capabilities. + */ +class RadioControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - The short friendly name of the climate control module. It should not be used to identify a + * module by mobile application. + * @return {RadioControlCapabilities} + */ + setModuleName (name) { + this.setParameter(RadioControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getModuleName () { + return this.getParameter(RadioControlCapabilities.KEY_MODULE_NAME); + } + + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {RadioControlCapabilities} + */ + setModuleInfo (info) { + this.validateType(ModuleInfo, info); + this.setParameter(RadioControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + + /** + * @return {ModuleInfo} + */ + getModuleInfo () { + return this.getObject(ModuleInfo, RadioControlCapabilities.KEY_MODULE_INFO); + } + + /** + * @param {Boolean} available - Availability of the control of enable/disable radio. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setRadioEnableAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getRadioEnableAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of radio band. True: Available, False: Not Available, + * Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setRadioBandAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getRadioBandAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of radio frequency. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setRadioFrequencyAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getRadioFrequencyAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of HD radio channel. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setHdChannelAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHdChannelAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the getting Radio Data System (RDS) data. True: Available, False: + * Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setRdsDataAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getRdsDataAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the getting the number of available HD channels. True: Available, + * False: Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setAvailableHDsAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getAvailableHDsAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the list of available HD sub-channel indexes. True: Available, + * False: Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setAvailableHdChannelsAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getAvailableHdChannelsAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the getting the Radio state. True: Available, False: Not Available, + * Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setStateAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_STATE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getStateAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_STATE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the getting the signal strength. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setSignalStrengthAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getSignalStrengthAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the getting the signal Change Threshold. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setSignalChangeThresholdAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getSignalChangeThresholdAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the getting HD radio Station Information Service (SIS) data. True: + * Available, False: Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setSisDataAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getSisDataAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of the control of enable/disable HD radio. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + setHdRadioEnableAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHdRadioEnableAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE); + } + + /** + * @param {Boolean} available - Availability of sirius XM radio. True: Available, False: Not Available, Not present: + * Not Available. + * @return {RadioControlCapabilities} + */ + setSiriusxmRadioAvailable (available) { + this.setParameter(RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getSiriusxmRadioAvailable () { + return this.getParameter(RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE); + } +} + +RadioControlCapabilities.KEY_MODULE_NAME = 'moduleName'; +RadioControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; +RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE = 'radioEnableAvailable'; +RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE = 'radioBandAvailable'; +RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE = 'radioFrequencyAvailable'; +RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE = 'hdChannelAvailable'; +RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE = 'rdsDataAvailable'; +RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE = 'availableHDsAvailable'; +RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE = 'availableHdChannelsAvailable'; +RadioControlCapabilities.KEY_STATE_AVAILABLE = 'stateAvailable'; +RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE = 'signalStrengthAvailable'; +RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE = 'signalChangeThresholdAvailable'; +RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE = 'sisDataAvailable'; +RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE = 'hdRadioEnableAvailable'; +RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE = 'siriusxmRadioAvailable'; + +export { RadioControlCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/RadioControlData.js b/lib/js/src/rpc/structs/RadioControlData.js new file mode 100644 index 00000000..c90540cf --- /dev/null +++ b/lib/js/src/rpc/structs/RadioControlData.js @@ -0,0 +1,280 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RadioBand } from '../enums/RadioBand.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { RdsData } from './RdsData.js'; +import { RadioState } from '../enums/RadioState.js'; +import { SisData } from './SisData.js'; + +class RadioControlData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} integer - The integer part of the frequency ie for 101.7 this value should be 101 + * @return {RadioControlData} + */ + setFrequencyInteger (integer) { + this.setParameter(RadioControlData.KEY_FREQUENCY_INTEGER, integer); + return this; + } + + /** + * @return {Number} + */ + getFrequencyInteger () { + return this.getParameter(RadioControlData.KEY_FREQUENCY_INTEGER); + } + + /** + * @param {Number} fraction - The fractional part of the frequency for 101.7 is 7 + * @return {RadioControlData} + */ + setFrequencyFraction (fraction) { + this.setParameter(RadioControlData.KEY_FREQUENCY_FRACTION, fraction); + return this; + } + + /** + * @return {Number} + */ + getFrequencyFraction () { + return this.getParameter(RadioControlData.KEY_FREQUENCY_FRACTION); + } + + /** + * @param {RadioBand} band + * @return {RadioControlData} + */ + setBand (band) { + this.validateType(RadioBand, band); + this.setParameter(RadioControlData.KEY_BAND, band); + return this; + } + + /** + * @return {RadioBand} + */ + getBand () { + return this.getObject(RadioBand, RadioControlData.KEY_BAND); + } + + /** + * @param {RdsData} data + * @return {RadioControlData} + */ + setRdsData (data) { + this.validateType(RdsData, data); + this.setParameter(RadioControlData.KEY_RDS_DATA, data); + return this; + } + + /** + * @return {RdsData} + */ + getRdsData () { + return this.getObject(RdsData, RadioControlData.KEY_RDS_DATA); + } + + /** + * @param {Boolean} enable - True if the hd radio is on, false if the radio is off + * @return {RadioControlData} + */ + setHdRadioEnable (enable) { + this.setParameter(RadioControlData.KEY_HD_RADIO_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getHdRadioEnable () { + return this.getParameter(RadioControlData.KEY_HD_RADIO_ENABLE); + } + + /** + * @param {Number} ds - Number of HD sub-channels if available + * @return {RadioControlData} + */ + setAvailableHDs (ds) { + this.setParameter(RadioControlData.KEY_AVAILABLE_HDS, ds); + return this; + } + + /** + * @return {Number} + */ + getAvailableHDs () { + return this.getParameter(RadioControlData.KEY_AVAILABLE_HDS); + } + + /** + * @param {Number[]} channels - The list of available HD sub-channel indexes. Empty list means no Hd channel is + * available. Read-only. + * @return {RadioControlData} + */ + setAvailableHdChannels (channels) { + this.setParameter(RadioControlData.KEY_AVAILABLE_HD_CHANNELS, channels); + return this; + } + + /** + * @return {Number[]} + */ + getAvailableHdChannels () { + return this.getParameter(RadioControlData.KEY_AVAILABLE_HD_CHANNELS); + } + + /** + * @param {Number} channel - Current HD sub-channel if available + * @return {RadioControlData} + */ + setHdChannel (channel) { + this.setParameter(RadioControlData.KEY_HD_CHANNEL, channel); + return this; + } + + /** + * @return {Number} + */ + getHdChannel () { + return this.getParameter(RadioControlData.KEY_HD_CHANNEL); + } + + /** + * @param {Number} strength + * @return {RadioControlData} + */ + setSignalStrength (strength) { + this.setParameter(RadioControlData.KEY_SIGNAL_STRENGTH, strength); + return this; + } + + /** + * @return {Number} + */ + getSignalStrength () { + return this.getParameter(RadioControlData.KEY_SIGNAL_STRENGTH); + } + + /** + * @param {Number} threshold - If the signal strength falls below the set value for this parameter, the radio will + * tune to an alternative frequency + * @return {RadioControlData} + */ + setSignalChangeThreshold (threshold) { + this.setParameter(RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD, threshold); + return this; + } + + /** + * @return {Number} + */ + getSignalChangeThreshold () { + return this.getParameter(RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD); + } + + /** + * @param {Boolean} enable - True if the radio is on, false if the radio is off. If set to false, no other data will + * be included. + * @return {RadioControlData} + */ + setRadioEnable (enable) { + this.setParameter(RadioControlData.KEY_RADIO_ENABLE, enable); + return this; + } + + /** + * @return {Boolean} + */ + getRadioEnable () { + return this.getParameter(RadioControlData.KEY_RADIO_ENABLE); + } + + /** + * @param {RadioState} state + * @return {RadioControlData} + */ + setState (state) { + this.validateType(RadioState, state); + this.setParameter(RadioControlData.KEY_STATE, state); + return this; + } + + /** + * @return {RadioState} + */ + getState () { + return this.getObject(RadioState, RadioControlData.KEY_STATE); + } + + /** + * @param {SisData} data - Read-only Station Information Service (SIS) data provides basic information about the + * station such as call sign, as well as information not displayable to the consumer such as + * the station identification number + * @return {RadioControlData} + */ + setSisData (data) { + this.validateType(SisData, data); + this.setParameter(RadioControlData.KEY_SIS_DATA, data); + return this; + } + + /** + * @return {SisData} + */ + getSisData () { + return this.getObject(SisData, RadioControlData.KEY_SIS_DATA); + } +} + +RadioControlData.KEY_FREQUENCY_INTEGER = 'frequencyInteger'; +RadioControlData.KEY_FREQUENCY_FRACTION = 'frequencyFraction'; +RadioControlData.KEY_BAND = 'band'; +RadioControlData.KEY_RDS_DATA = 'rdsData'; +RadioControlData.KEY_HD_RADIO_ENABLE = 'hdRadioEnable'; +RadioControlData.KEY_AVAILABLE_HDS = 'availableHDs'; +RadioControlData.KEY_AVAILABLE_HD_CHANNELS = 'availableHdChannels'; +RadioControlData.KEY_HD_CHANNEL = 'hdChannel'; +RadioControlData.KEY_SIGNAL_STRENGTH = 'signalStrength'; +RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD = 'signalChangeThreshold'; +RadioControlData.KEY_RADIO_ENABLE = 'radioEnable'; +RadioControlData.KEY_STATE = 'state'; +RadioControlData.KEY_SIS_DATA = 'sisData'; + +export { RadioControlData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/RdsData.js b/lib/js/src/rpc/structs/RdsData.js new file mode 100644 index 00000000..2a17b7f7 --- /dev/null +++ b/lib/js/src/rpc/structs/RdsData.js @@ -0,0 +1,183 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class RdsData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} ps - Program Service Name + * @return {RdsData} + */ + setPS (ps) { + this.setParameter(RdsData.KEY_PS, ps); + return this; + } + + /** + * @return {String} + */ + getPS () { + return this.getParameter(RdsData.KEY_PS); + } + + /** + * @param {String} rt - Radio Text + * @return {RdsData} + */ + setRT (rt) { + this.setParameter(RdsData.KEY_RT, rt); + return this; + } + + /** + * @return {String} + */ + getRT () { + return this.getParameter(RdsData.KEY_RT); + } + + /** + * @param {String} ct - The clock text in UTC format as YYYY-MM-DDThh:mm:ss.sTZD + * @return {RdsData} + */ + setCT (ct) { + this.setParameter(RdsData.KEY_CT, ct); + return this; + } + + /** + * @return {String} + */ + getCT () { + return this.getParameter(RdsData.KEY_CT); + } + + /** + * @param {String} pi - Program Identification - the call sign for the radio station + * @return {RdsData} + */ + setPI (pi) { + this.setParameter(RdsData.KEY_PI, pi); + return this; + } + + /** + * @return {String} + */ + getPI () { + return this.getParameter(RdsData.KEY_PI); + } + + /** + * @param {Number} pty - The program type - The region should be used to differentiate between EU and North America + * program types + * @return {RdsData} + */ + setPTY (pty) { + this.setParameter(RdsData.KEY_PTY, pty); + return this; + } + + /** + * @return {Number} + */ + getPTY () { + return this.getParameter(RdsData.KEY_PTY); + } + + /** + * @param {Boolean} tp - Traffic Program Identification - Identifies a station that offers traffic + * @return {RdsData} + */ + setTP (tp) { + this.setParameter(RdsData.KEY_TP, tp); + return this; + } + + /** + * @return {Boolean} + */ + getTP () { + return this.getParameter(RdsData.KEY_TP); + } + + /** + * @param {Boolean} ta - Traffic Announcement Identification - Indicates an ongoing traffic announcement + * @return {RdsData} + */ + setTA (ta) { + this.setParameter(RdsData.KEY_TA, ta); + return this; + } + + /** + * @return {Boolean} + */ + getTA () { + return this.getParameter(RdsData.KEY_TA); + } + + /** + * @param {String} reg - Region + * @return {RdsData} + */ + setREG (reg) { + this.setParameter(RdsData.KEY_REG, reg); + return this; + } + + /** + * @return {String} + */ + getREG () { + return this.getParameter(RdsData.KEY_REG); + } +} + +RdsData.KEY_PS = 'PS'; +RdsData.KEY_RT = 'RT'; +RdsData.KEY_CT = 'CT'; +RdsData.KEY_PI = 'PI'; +RdsData.KEY_PTY = 'PTY'; +RdsData.KEY_TP = 'TP'; +RdsData.KEY_TA = 'TA'; +RdsData.KEY_REG = 'REG'; + +export { RdsData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/Rectangle.js b/lib/js/src/rpc/structs/Rectangle.js new file mode 100644 index 00000000..67e91447 --- /dev/null +++ b/lib/js/src/rpc/structs/Rectangle.js @@ -0,0 +1,114 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class Rectangle extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} x - The upper left X-coordinate of the rectangle + * @return {Rectangle} + */ + setX (x) { + this.setParameter(Rectangle.KEY_X, x); + return this; + } + + /** + * @return {Number} + */ + getX () { + return this.getParameter(Rectangle.KEY_X); + } + + /** + * @param {Number} y - The upper left Y-coordinate of the rectangle + * @return {Rectangle} + */ + setY (y) { + this.setParameter(Rectangle.KEY_Y, y); + return this; + } + + /** + * @return {Number} + */ + getY () { + return this.getParameter(Rectangle.KEY_Y); + } + + /** + * @param {Number} width - The width of the rectangle + * @return {Rectangle} + */ + setWidth (width) { + this.setParameter(Rectangle.KEY_WIDTH, width); + return this; + } + + /** + * @return {Number} + */ + getWidth () { + return this.getParameter(Rectangle.KEY_WIDTH); + } + + /** + * @param {Number} height - The height of the rectangle + * @return {Rectangle} + */ + setHeight (height) { + this.setParameter(Rectangle.KEY_HEIGHT, height); + return this; + } + + /** + * @return {Number} + */ + getHeight () { + return this.getParameter(Rectangle.KEY_HEIGHT); + } +} + +Rectangle.KEY_X = 'x'; +Rectangle.KEY_Y = 'y'; +Rectangle.KEY_WIDTH = 'width'; +Rectangle.KEY_HEIGHT = 'height'; + +export { Rectangle }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/RemoteControlCapabilities.js b/lib/js/src/rpc/structs/RemoteControlCapabilities.js new file mode 100644 index 00000000..89c5f444 --- /dev/null +++ b/lib/js/src/rpc/structs/RemoteControlCapabilities.js @@ -0,0 +1,184 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { AudioControlCapabilities } from './AudioControlCapabilities.js'; +import { LightControlCapabilities } from './LightControlCapabilities.js'; +import { ClimateControlCapabilities } from './ClimateControlCapabilities.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { ButtonCapabilities } from './ButtonCapabilities.js'; +import { SeatControlCapabilities } from './SeatControlCapabilities.js'; +import { RadioControlCapabilities } from './RadioControlCapabilities.js'; +import { HMISettingsControlCapabilities } from './HMISettingsControlCapabilities.js'; + +class RemoteControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {ClimateControlCapabilities[]} capabilities - If included, the platform supports RC climate controls. For + * this baseline version, maxsize=1. i.e. only one climate + * control module is supported. + * @return {RemoteControlCapabilities} + */ + setClimateControlCapabilities (capabilities) { + this.validateType(ClimateControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {ClimateControlCapabilities[]} + */ + getClimateControlCapabilities () { + return this.getObject(ClimateControlCapabilities, RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES); + } + + /** + * @param {RadioControlCapabilities[]} capabilities - If included, the platform supports RC radio controls.For this + * baseline version, maxsize=1. i.e. only one radio control + * module is supported. + * @return {RemoteControlCapabilities} + */ + setRadioControlCapabilities (capabilities) { + this.validateType(RadioControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {RadioControlCapabilities[]} + */ + getRadioControlCapabilities () { + return this.getObject(RadioControlCapabilities, RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES); + } + + /** + * @param {ButtonCapabilities[]} capabilities - If included, the platform supports RC button controls with the + * included button names. + * @return {RemoteControlCapabilities} + */ + setButtonCapabilities (capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {ButtonCapabilities[]} + */ + getButtonCapabilities () { + return this.getObject(ButtonCapabilities, RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES); + } + + /** + * @param {AudioControlCapabilities[]} capabilities - If included, the platform supports audio controls. + * @return {RemoteControlCapabilities} + */ + setAudioControlCapabilities (capabilities) { + this.validateType(AudioControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {AudioControlCapabilities[]} + */ + getAudioControlCapabilities () { + return this.getObject(AudioControlCapabilities, RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES); + } + + /** + * @param {HMISettingsControlCapabilities} capabilities - If included, the platform supports hmi setting controls. + * @return {RemoteControlCapabilities} + */ + setHmiSettingsControlCapabilities (capabilities) { + this.validateType(HMISettingsControlCapabilities, capabilities); + this.setParameter(RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {HMISettingsControlCapabilities} + */ + getHmiSettingsControlCapabilities () { + return this.getObject(HMISettingsControlCapabilities, RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES); + } + + /** + * @param {LightControlCapabilities} capabilities - If included, the platform supports light controls. + * @return {RemoteControlCapabilities} + */ + setLightControlCapabilities (capabilities) { + this.validateType(LightControlCapabilities, capabilities); + this.setParameter(RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {LightControlCapabilities} + */ + getLightControlCapabilities () { + return this.getObject(LightControlCapabilities, RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES); + } + + /** + * @param {SeatControlCapabilities[]} capabilities - If included, the platform supports seat controls. + * @return {RemoteControlCapabilities} + */ + setSeatControlCapabilities (capabilities) { + this.validateType(SeatControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {SeatControlCapabilities[]} + */ + getSeatControlCapabilities () { + return this.getObject(SeatControlCapabilities, RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES); + } +} + +RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES = 'climateControlCapabilities'; +RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES = 'radioControlCapabilities'; +RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; +RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES = 'audioControlCapabilities'; +RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES = 'hmiSettingsControlCapabilities'; +RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES = 'lightControlCapabilities'; +RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES = 'seatControlCapabilities'; + +export { RemoteControlCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/ScreenParams.js b/lib/js/src/rpc/structs/ScreenParams.js index cd82d4b6..d53f2c28 100644 --- a/lib/js/src/rpc/structs/ScreenParams.js +++ b/lib/js/src/rpc/structs/ScreenParams.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -35,43 +36,43 @@ import { ImageResolution } from './ImageResolution.js'; import { TouchEventCapabilities } from './TouchEventCapabilities.js'; class ScreenParams extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } - /** - * @param {ImageResolution} resolution - * @return {ScreenParams} - */ + * @param {ImageResolution} resolution - The resolution of the prescribed screen area. + * @return {ScreenParams} + */ setResolution (resolution) { this.validateType(ImageResolution, resolution); - this.setParameter(ScreenParams.KEY_RESOLUTION, resolution); return this; } /** - * @return {ImageResolution} - */ + * @return {ImageResolution} + */ getResolution () { return this.getObject(ImageResolution, ScreenParams.KEY_RESOLUTION); } /** - * @param {TouchEventCapabilities} touchEventCapabilities - * @return {ScreenParams} - */ - setTouchEventAvailable (touchEventCapabilities) { - this.validateType(TouchEventCapabilities, touchEventCapabilities); - - this.setParameter(ScreenParams.KEY_TOUCH_EVENT_AVAILABLE, touchEventCapabilities); + * @param {TouchEventCapabilities} available - Types of screen touch events available in screen area. + * @return {ScreenParams} + */ + setTouchEventAvailable (available) { + this.validateType(TouchEventCapabilities, available); + this.setParameter(ScreenParams.KEY_TOUCH_EVENT_AVAILABLE, available); return this; } /** - * @return {TouchEventCapabilities} - */ + * @return {TouchEventCapabilities} + */ getTouchEventAvailable () { return this.getObject(TouchEventCapabilities, ScreenParams.KEY_TOUCH_EVENT_AVAILABLE); } @@ -80,4 +81,4 @@ class ScreenParams extends RpcStruct { ScreenParams.KEY_RESOLUTION = 'resolution'; ScreenParams.KEY_TOUCH_EVENT_AVAILABLE = 'touchEventAvailable'; -export { ScreenParams }; +export { ScreenParams }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SdlMsgVersion.js b/lib/js/src/rpc/structs/SdlMsgVersion.js index 99f103b5..6e1ea261 100644 --- a/lib/js/src/rpc/structs/SdlMsgVersion.js +++ b/lib/js/src/rpc/structs/SdlMsgVersion.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,55 +33,63 @@ import { RpcStruct } from '../RpcStruct.js'; +/** + * Specifies the version number of the SmartDeviceLink protocol that is supported by the mobile application + */ class SdlMsgVersion extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Number} the major version of this object - * @return {SdlMsgVersion} - */ - setMajorVersion (value) { - this.setParameter(SdlMsgVersion.KEY_MAJOR_VERSION, value); + * @param {Number} version - The major version indicates versions that is not-compatible to previous versions. + * @return {SdlMsgVersion} + */ + setMajorVersion (version) { + this.setParameter(SdlMsgVersion.KEY_MAJOR_VERSION, version); return this; } /** - * @return {Number} the major version of this object - */ + * @return {Number} + */ getMajorVersion () { return this.getParameter(SdlMsgVersion.KEY_MAJOR_VERSION); } /** - * @param {Number} the minor version of this object - * @return {SdlMsgVersion} - */ - setMinorVersion (value) { - this.setParameter(SdlMsgVersion.KEY_MINOR_VERSION, value); + * @param {Number} version - The minor version indicates a change to a previous version that should still allow to + * be run on an older version (with limited functionality) + * @return {SdlMsgVersion} + */ + setMinorVersion (version) { + this.setParameter(SdlMsgVersion.KEY_MINOR_VERSION, version); return this; } /** - * @return {Number} the minor version of this object - */ + * @return {Number} + */ getMinorVersion () { return this.getParameter(SdlMsgVersion.KEY_MINOR_VERSION); } /** - * @param {Number} the patch version of this object - * @return {SdlMsgVersion} - */ - setPatchVersion (value) { - this.setParameter(SdlMsgVersion.KEY_PATCH_VERSION, value); + * @param {Number} version - The patch version indicates a fix to existing functionality in a previous version that + * should still be able to be run on an older version + * @return {SdlMsgVersion} + */ + setPatchVersion (version) { + this.setParameter(SdlMsgVersion.KEY_PATCH_VERSION, version); return this; } /** - * @return {Number} the patch version of this objects - */ + * @return {Number} + */ getPatchVersion () { return this.getParameter(SdlMsgVersion.KEY_PATCH_VERSION); } @@ -90,4 +99,4 @@ SdlMsgVersion.KEY_MAJOR_VERSION = 'majorVersion'; SdlMsgVersion.KEY_MINOR_VERSION = 'minorVersion'; SdlMsgVersion.KEY_PATCH_VERSION = 'patchVersion'; -export { SdlMsgVersion }; +export { SdlMsgVersion }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SeatControlCapabilities.js b/lib/js/src/rpc/structs/SeatControlCapabilities.js new file mode 100644 index 00000000..ed2953bc --- /dev/null +++ b/lib/js/src/rpc/structs/SeatControlCapabilities.js @@ -0,0 +1,338 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { ModuleInfo } from './ModuleInfo.js'; + +class SeatControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - The short friendly name of the light control module. It should not be used to identify a + * module by mobile application. + * @return {SeatControlCapabilities} + */ + setModuleName (name) { + this.setParameter(SeatControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + + /** + * @return {String} + */ + getModuleName () { + return this.getParameter(SeatControlCapabilities.KEY_MODULE_NAME); + } + + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {SeatControlCapabilities} + */ + setModuleInfo (info) { + this.validateType(ModuleInfo, info); + this.setParameter(SeatControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + + /** + * @return {ModuleInfo} + */ + getModuleInfo () { + return this.getObject(ModuleInfo, SeatControlCapabilities.KEY_MODULE_INFO); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setHeatingEnabledAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeatingEnabledAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setCoolingEnabledAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getCoolingEnabledAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setHeatingLevelAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeatingLevelAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setCoolingLevelAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getCoolingLevelAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setHorizontalPositionAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHorizontalPositionAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setVerticalPositionAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getVerticalPositionAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setFrontVerticalPositionAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getFrontVerticalPositionAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setBackVerticalPositionAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getBackVerticalPositionAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setBackTiltAngleAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getBackTiltAngleAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setHeadSupportHorizontalPositionAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeadSupportHorizontalPositionAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setHeadSupportVerticalPositionAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getHeadSupportVerticalPositionAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setMassageEnabledAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getMassageEnabledAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setMassageModeAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getMassageModeAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setMassageCushionFirmnessAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getMassageCushionFirmnessAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE); + } + + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + setMemoryAvailable (available) { + this.setParameter(SeatControlCapabilities.KEY_MEMORY_AVAILABLE, available); + return this; + } + + /** + * @return {Boolean} + */ + getMemoryAvailable () { + return this.getParameter(SeatControlCapabilities.KEY_MEMORY_AVAILABLE); + } +} + +SeatControlCapabilities.KEY_MODULE_NAME = 'moduleName'; +SeatControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; +SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE = 'heatingEnabledAvailable'; +SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE = 'coolingEnabledAvailable'; +SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE = 'heatingLevelAvailable'; +SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE = 'coolingLevelAvailable'; +SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE = 'horizontalPositionAvailable'; +SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE = 'verticalPositionAvailable'; +SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE = 'frontVerticalPositionAvailable'; +SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE = 'backVerticalPositionAvailable'; +SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE = 'backTiltAngleAvailable'; +SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE = 'headSupportHorizontalPositionAvailable'; +SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE = 'headSupportVerticalPositionAvailable'; +SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE = 'massageEnabledAvailable'; +SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE = 'massageModeAvailable'; +SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE = 'massageCushionFirmnessAvailable'; +SeatControlCapabilities.KEY_MEMORY_AVAILABLE = 'memoryAvailable'; + +export { SeatControlCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SeatControlData.js b/lib/js/src/rpc/structs/SeatControlData.js new file mode 100644 index 00000000..70a8e36f --- /dev/null +++ b/lib/js/src/rpc/structs/SeatControlData.js @@ -0,0 +1,329 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { MassageCushionFirmness } from './MassageCushionFirmness.js'; +import { SupportedSeat } from '../enums/SupportedSeat.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { SeatMemoryAction } from './SeatMemoryAction.js'; +import { MassageModeData } from './MassageModeData.js'; + +/** + * Seat control data corresponds to "SEAT" ModuleType. + */ +class SeatControlData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {SupportedSeat} id - List possible seats that is a remote controllable seat. + * @return {SeatControlData} + */ + setId (id) { + this.validateType(SupportedSeat, id); + this.setParameter(SeatControlData.KEY_ID, id); + return this; + } + + /** + * @return {SupportedSeat} + */ + getId () { + return this.getObject(SupportedSeat, SeatControlData.KEY_ID); + } + + /** + * @param {Boolean} enabled + * @return {SeatControlData} + */ + setHeatingEnabled (enabled) { + this.setParameter(SeatControlData.KEY_HEATING_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getHeatingEnabled () { + return this.getParameter(SeatControlData.KEY_HEATING_ENABLED); + } + + /** + * @param {Boolean} enabled + * @return {SeatControlData} + */ + setCoolingEnabled (enabled) { + this.setParameter(SeatControlData.KEY_COOLING_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getCoolingEnabled () { + return this.getParameter(SeatControlData.KEY_COOLING_ENABLED); + } + + /** + * @param {Number} level + * @return {SeatControlData} + */ + setHeatingLevel (level) { + this.setParameter(SeatControlData.KEY_HEATING_LEVEL, level); + return this; + } + + /** + * @return {Number} + */ + getHeatingLevel () { + return this.getParameter(SeatControlData.KEY_HEATING_LEVEL); + } + + /** + * @param {Number} level + * @return {SeatControlData} + */ + setCoolingLevel (level) { + this.setParameter(SeatControlData.KEY_COOLING_LEVEL, level); + return this; + } + + /** + * @return {Number} + */ + getCoolingLevel () { + return this.getParameter(SeatControlData.KEY_COOLING_LEVEL); + } + + /** + * @param {Number} position + * @return {SeatControlData} + */ + setHorizontalPosition (position) { + this.setParameter(SeatControlData.KEY_HORIZONTAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getHorizontalPosition () { + return this.getParameter(SeatControlData.KEY_HORIZONTAL_POSITION); + } + + /** + * @param {Number} position + * @return {SeatControlData} + */ + setVerticalPosition (position) { + this.setParameter(SeatControlData.KEY_VERTICAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getVerticalPosition () { + return this.getParameter(SeatControlData.KEY_VERTICAL_POSITION); + } + + /** + * @param {Number} position + * @return {SeatControlData} + */ + setFrontVerticalPosition (position) { + this.setParameter(SeatControlData.KEY_FRONT_VERTICAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getFrontVerticalPosition () { + return this.getParameter(SeatControlData.KEY_FRONT_VERTICAL_POSITION); + } + + /** + * @param {Number} position + * @return {SeatControlData} + */ + setBackVerticalPosition (position) { + this.setParameter(SeatControlData.KEY_BACK_VERTICAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getBackVerticalPosition () { + return this.getParameter(SeatControlData.KEY_BACK_VERTICAL_POSITION); + } + + /** + * @param {Number} angle + * @return {SeatControlData} + */ + setBackTiltAngle (angle) { + this.setParameter(SeatControlData.KEY_BACK_TILT_ANGLE, angle); + return this; + } + + /** + * @return {Number} + */ + getBackTiltAngle () { + return this.getParameter(SeatControlData.KEY_BACK_TILT_ANGLE); + } + + /** + * @param {Number} position + * @return {SeatControlData} + */ + setHeadSupportHorizontalPosition (position) { + this.setParameter(SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getHeadSupportHorizontalPosition () { + return this.getParameter(SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION); + } + + /** + * @param {Number} position + * @return {SeatControlData} + */ + setHeadSupportVerticalPosition (position) { + this.setParameter(SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getHeadSupportVerticalPosition () { + return this.getParameter(SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION); + } + + /** + * @param {Boolean} enabled + * @return {SeatControlData} + */ + setMassageEnabled (enabled) { + this.setParameter(SeatControlData.KEY_MASSAGE_ENABLED, enabled); + return this; + } + + /** + * @return {Boolean} + */ + getMassageEnabled () { + return this.getParameter(SeatControlData.KEY_MASSAGE_ENABLED); + } + + /** + * @param {MassageModeData[]} mode - Specify the mode of a massage zone. + * @return {SeatControlData} + */ + setMassageMode (mode) { + this.validateType(MassageModeData, mode, true); + this.setParameter(SeatControlData.KEY_MASSAGE_MODE, mode); + return this; + } + + /** + * @return {MassageModeData[]} + */ + getMassageMode () { + return this.getObject(MassageModeData, SeatControlData.KEY_MASSAGE_MODE); + } + + /** + * @param {MassageCushionFirmness[]} firmness - The intensity or firmness of a cushion. + * @return {SeatControlData} + */ + setMassageCushionFirmness (firmness) { + this.validateType(MassageCushionFirmness, firmness, true); + this.setParameter(SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS, firmness); + return this; + } + + /** + * @return {MassageCushionFirmness[]} + */ + getMassageCushionFirmness () { + return this.getObject(MassageCushionFirmness, SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS); + } + + /** + * @param {SeatMemoryAction} memory + * @return {SeatControlData} + */ + setMemory (memory) { + this.validateType(SeatMemoryAction, memory); + this.setParameter(SeatControlData.KEY_MEMORY, memory); + return this; + } + + /** + * @return {SeatMemoryAction} + */ + getMemory () { + return this.getObject(SeatMemoryAction, SeatControlData.KEY_MEMORY); + } +} + +SeatControlData.KEY_ID = 'id'; +SeatControlData.KEY_HEATING_ENABLED = 'heatingEnabled'; +SeatControlData.KEY_COOLING_ENABLED = 'coolingEnabled'; +SeatControlData.KEY_HEATING_LEVEL = 'heatingLevel'; +SeatControlData.KEY_COOLING_LEVEL = 'coolingLevel'; +SeatControlData.KEY_HORIZONTAL_POSITION = 'horizontalPosition'; +SeatControlData.KEY_VERTICAL_POSITION = 'verticalPosition'; +SeatControlData.KEY_FRONT_VERTICAL_POSITION = 'frontVerticalPosition'; +SeatControlData.KEY_BACK_VERTICAL_POSITION = 'backVerticalPosition'; +SeatControlData.KEY_BACK_TILT_ANGLE = 'backTiltAngle'; +SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION = 'headSupportHorizontalPosition'; +SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION = 'headSupportVerticalPosition'; +SeatControlData.KEY_MASSAGE_ENABLED = 'massageEnabled'; +SeatControlData.KEY_MASSAGE_MODE = 'massageMode'; +SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS = 'massageCushionFirmness'; +SeatControlData.KEY_MEMORY = 'memory'; + +export { SeatControlData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SeatLocation.js b/lib/js/src/rpc/structs/SeatLocation.js new file mode 100644 index 00000000..3fe46eab --- /dev/null +++ b/lib/js/src/rpc/structs/SeatLocation.js @@ -0,0 +1,68 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { Grid } from './Grid.js'; + +/** + * Describes the location of a seat. + */ +class SeatLocation extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Grid} grid - Describes a location (origin coordinates and span) of a vehicle component. + * @return {SeatLocation} + */ + setGrid (grid) { + this.validateType(Grid, grid); + this.setParameter(SeatLocation.KEY_GRID, grid); + return this; + } + + /** + * @return {Grid} + */ + getGrid () { + return this.getObject(Grid, SeatLocation.KEY_GRID); + } +} + +SeatLocation.KEY_GRID = 'grid'; + +export { SeatLocation }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SeatLocationCapability.js b/lib/js/src/rpc/structs/SeatLocationCapability.js new file mode 100644 index 00000000..d70c3db7 --- /dev/null +++ b/lib/js/src/rpc/structs/SeatLocationCapability.js @@ -0,0 +1,119 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { SeatLocation } from './SeatLocation.js'; + +/** + * Contains information about the locations of each seat + */ +class SeatLocationCapability extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} rows + * @return {SeatLocationCapability} + */ + setRows (rows) { + this.setParameter(SeatLocationCapability.KEY_ROWS, rows); + return this; + } + + /** + * @return {Number} + */ + getRows () { + return this.getParameter(SeatLocationCapability.KEY_ROWS); + } + + /** + * @param {Number} columns + * @return {SeatLocationCapability} + */ + setColumns (columns) { + this.setParameter(SeatLocationCapability.KEY_COLUMNS, columns); + return this; + } + + /** + * @return {Number} + */ + getColumns () { + return this.getParameter(SeatLocationCapability.KEY_COLUMNS); + } + + /** + * @param {Number} levels + * @return {SeatLocationCapability} + */ + setLevels (levels) { + this.setParameter(SeatLocationCapability.KEY_LEVELS, levels); + return this; + } + + /** + * @return {Number} + */ + getLevels () { + return this.getParameter(SeatLocationCapability.KEY_LEVELS); + } + + /** + * @param {SeatLocation[]} seats - Contains a list of SeatLocation in the vehicle + * @return {SeatLocationCapability} + */ + setSeats (seats) { + this.validateType(SeatLocation, seats, true); + this.setParameter(SeatLocationCapability.KEY_SEATS, seats); + return this; + } + + /** + * @return {SeatLocation[]} + */ + getSeats () { + return this.getObject(SeatLocation, SeatLocationCapability.KEY_SEATS); + } +} + +SeatLocationCapability.KEY_ROWS = 'rows'; +SeatLocationCapability.KEY_COLUMNS = 'columns'; +SeatLocationCapability.KEY_LEVELS = 'levels'; +SeatLocationCapability.KEY_SEATS = 'seats'; + +export { SeatLocationCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SeatMemoryAction.js b/lib/js/src/rpc/structs/SeatMemoryAction.js new file mode 100644 index 00000000..f8148fb6 --- /dev/null +++ b/lib/js/src/rpc/structs/SeatMemoryAction.js @@ -0,0 +1,99 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { SeatMemoryActionType } from '../enums/SeatMemoryActionType.js'; + +class SeatMemoryAction extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} id + * @return {SeatMemoryAction} + */ + setId (id) { + this.setParameter(SeatMemoryAction.KEY_ID, id); + return this; + } + + /** + * @return {Number} + */ + getId () { + return this.getParameter(SeatMemoryAction.KEY_ID); + } + + /** + * @param {String} label + * @return {SeatMemoryAction} + */ + setLabel (label) { + this.setParameter(SeatMemoryAction.KEY_LABEL, label); + return this; + } + + /** + * @return {String} + */ + getLabel () { + return this.getParameter(SeatMemoryAction.KEY_LABEL); + } + + /** + * @param {SeatMemoryActionType} action + * @return {SeatMemoryAction} + */ + setAction (action) { + this.validateType(SeatMemoryActionType, action); + this.setParameter(SeatMemoryAction.KEY_ACTION, action); + return this; + } + + /** + * @return {SeatMemoryActionType} + */ + getAction () { + return this.getObject(SeatMemoryActionType, SeatMemoryAction.KEY_ACTION); + } +} + +SeatMemoryAction.KEY_ID = 'id'; +SeatMemoryAction.KEY_LABEL = 'label'; +SeatMemoryAction.KEY_ACTION = 'action'; + +export { SeatMemoryAction }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SingleTireStatus.js b/lib/js/src/rpc/structs/SingleTireStatus.js new file mode 100644 index 00000000..3299370c --- /dev/null +++ b/lib/js/src/rpc/structs/SingleTireStatus.js @@ -0,0 +1,101 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { ComponentVolumeStatus } from '../enums/ComponentVolumeStatus.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { TPMS } from '../enums/TPMS.js'; + +class SingleTireStatus extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {ComponentVolumeStatus} status - See ComponentVolumeStatus. + * @return {SingleTireStatus} + */ + setStatus (status) { + this.validateType(ComponentVolumeStatus, status); + this.setParameter(SingleTireStatus.KEY_STATUS, status); + return this; + } + + /** + * @return {ComponentVolumeStatus} + */ + getStatus () { + return this.getObject(ComponentVolumeStatus, SingleTireStatus.KEY_STATUS); + } + + /** + * @param {TPMS} tpms - The status of TPMS according to the particular tire. + * @return {SingleTireStatus} + */ + setTpms (tpms) { + this.validateType(TPMS, tpms); + this.setParameter(SingleTireStatus.KEY_TPMS, tpms); + return this; + } + + /** + * @return {TPMS} + */ + getTpms () { + return this.getObject(TPMS, SingleTireStatus.KEY_TPMS); + } + + /** + * @param {Number} pressure - The pressure value of the particular tire in kilo pascal. + * @return {SingleTireStatus} + */ + setPressure (pressure) { + this.setParameter(SingleTireStatus.KEY_PRESSURE, pressure); + return this; + } + + /** + * @return {Number} + */ + getPressure () { + return this.getParameter(SingleTireStatus.KEY_PRESSURE); + } +} + +SingleTireStatus.KEY_STATUS = 'status'; +SingleTireStatus.KEY_TPMS = 'tpms'; +SingleTireStatus.KEY_PRESSURE = 'pressure'; + +export { SingleTireStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SisData.js b/lib/js/src/rpc/structs/SisData.js new file mode 100644 index 00000000..d8d3272d --- /dev/null +++ b/lib/js/src/rpc/structs/SisData.js @@ -0,0 +1,137 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { GPSData } from './GPSData.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { StationIDNumber } from './StationIDNumber.js'; + +class SisData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} name - Identifies the 4-alpha-character station call sign plus an optional (-FM) extension + * @return {SisData} + */ + setStationShortName (name) { + this.setParameter(SisData.KEY_STATION_SHORT_NAME, name); + return this; + } + + /** + * @return {String} + */ + getStationShortName () { + return this.getParameter(SisData.KEY_STATION_SHORT_NAME); + } + + /** + * @param {StationIDNumber} number - Used for network Application. Consists of Country Code and FCC Facility ID. + * @return {SisData} + */ + setStationIDNumber (number) { + this.validateType(StationIDNumber, number); + this.setParameter(SisData.KEY_STATION_IDNUMBER, number); + return this; + } + + /** + * @return {StationIDNumber} + */ + getStationIDNumber () { + return this.getObject(StationIDNumber, SisData.KEY_STATION_IDNUMBER); + } + + /** + * @param {String} name - Identifies the station call sign or other identifying information in the long format. + * @return {SisData} + */ + setStationLongName (name) { + this.setParameter(SisData.KEY_STATION_LONG_NAME, name); + return this; + } + + /** + * @return {String} + */ + getStationLongName () { + return this.getParameter(SisData.KEY_STATION_LONG_NAME); + } + + /** + * @param {GPSData} location - Provides the 3-dimensional geographic station location. + * @return {SisData} + */ + setStationLocation (location) { + this.validateType(GPSData, location); + this.setParameter(SisData.KEY_STATION_LOCATION, location); + return this; + } + + /** + * @return {GPSData} + */ + getStationLocation () { + return this.getObject(GPSData, SisData.KEY_STATION_LOCATION); + } + + /** + * @param {String} message - May be used to convey textual information of general interest to the consumer such as + * weather forecasts or public service announcements. Includes a high priority delivery + * feature to convey emergencies that may be in the listening area. + * @return {SisData} + */ + setStationMessage (message) { + this.setParameter(SisData.KEY_STATION_MESSAGE, message); + return this; + } + + /** + * @return {String} + */ + getStationMessage () { + return this.getParameter(SisData.KEY_STATION_MESSAGE); + } +} + +SisData.KEY_STATION_SHORT_NAME = 'stationShortName'; +SisData.KEY_STATION_IDNUMBER = 'stationIDNumber'; +SisData.KEY_STATION_LONG_NAME = 'stationLongName'; +SisData.KEY_STATION_LOCATION = 'stationLocation'; +SisData.KEY_STATION_MESSAGE = 'stationMessage'; + +export { SisData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SoftButton.js b/lib/js/src/rpc/structs/SoftButton.js index fb875de4..14398b6d 100644 --- a/lib/js/src/rpc/structs/SoftButton.js +++ b/lib/js/src/rpc/structs/SoftButton.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,114 +33,116 @@ import { RpcStruct } from '../RpcStruct.js'; import { SoftButtonType } from '../enums/SoftButtonType.js'; -import { SystemAction } from '../enums/SystemAction.js'; import { Image } from './Image.js'; - +import { SystemAction } from '../enums/SystemAction.js'; class SoftButton extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {SoftButtonType} type - * @return {SoftButton} - */ + * @param {SoftButtonType} type - Describes, whether it is text, highlighted text, icon, or dynamic image. See + * softButtonType + * @return {SoftButton} + */ setType (type) { this.validateType(SoftButtonType, type); - this.setParameter(SoftButton.KEY_TYPE, type); return this; } /** - * @return {SoftButtonType} - */ + * @return {SoftButtonType} + */ getType () { return this.getObject(SoftButtonType, SoftButton.KEY_TYPE); } /** - * @param {String} text - * @return {SoftButton} - */ + * @param {String} text - Optional text to display (if defined as TEXT or BOTH) + * @return {SoftButton} + */ setText (text) { this.setParameter(SoftButton.KEY_TEXT, text); return this; } /** - * @return {String} - */ + * @return {String} + */ getText () { return this.getParameter(SoftButton.KEY_TEXT); } /** - * @param {Image} image - * @return {SoftButton} - */ + * @param {Image} image - Optional image struct for SoftButton (if defined as IMAGE or BOTH) + * @return {SoftButton} + */ setImage (image) { this.validateType(Image, image); - this.setParameter(SoftButton.KEY_IMAGE, image); return this; } /** - * @return {Image} - */ + * @return {Image} + */ getImage () { return this.getObject(Image, SoftButton.KEY_IMAGE); } /** - * @param {Boolean} isHighlighted - * @return {SoftButton} - */ - setIsHighlighted (isHighlighted) { - this.setParameter(SoftButton.KEY_IS_HIGHLIGHTED, isHighlighted); + * @param {Boolean} highlighted - True, if highlighted False, if not highlighted + * @return {SoftButton} + */ + setIsHighlighted (highlighted) { + this.setParameter(SoftButton.KEY_IS_HIGHLIGHTED, highlighted); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getIsHighlighted () { return this.getParameter(SoftButton.KEY_IS_HIGHLIGHTED); } /** - * @param {Number} softButtonID - * @return {SoftButton} - */ - setSoftButtonID (softButtonID) { - this.setParameter(SoftButton.KEY_SOFT_BUTTON_ID, softButtonID); + * @param {Number} id - Value which is returned via OnButtonPress / OnButtonEvent + * @return {SoftButton} + */ + setSoftButtonID (id) { + this.setParameter(SoftButton.KEY_SOFT_BUTTON_ID, id); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getSoftButtonID () { return this.getParameter(SoftButton.KEY_SOFT_BUTTON_ID); } - /** - * @param {SystemAction} systemAction - * @return {SoftButton} - */ - setSystemAction (systemAction) { - this.validateType(SystemAction, systemAction); - - this.setParameter(SoftButton.KEY_SYSTEM_ACTION, systemAction); + * @param {SystemAction} action - Parameter indicating whether selecting a SoftButton shall call a specific system + * action. This is intended to allow Notifications to bring the callee into full / + * focus; or in the case of persistent overlays, the overlay can persist when a + * SoftButton is pressed. + * @return {SoftButton} + */ + setSystemAction (action) { + this.validateType(SystemAction, action); + this.setParameter(SoftButton.KEY_SYSTEM_ACTION, action); return this; } /** - * @return {SystemAction} - */ + * @return {SystemAction} + */ getSystemAction () { return this.getObject(SystemAction, SoftButton.KEY_SYSTEM_ACTION); } @@ -152,4 +155,4 @@ SoftButton.KEY_IS_HIGHLIGHTED = 'isHighlighted'; SoftButton.KEY_SOFT_BUTTON_ID = 'softButtonID'; SoftButton.KEY_SYSTEM_ACTION = 'systemAction'; -export { SoftButton }; +export { SoftButton }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SoftButtonCapabilities.js b/lib/js/src/rpc/structs/SoftButtonCapabilities.js index d76f975d..7c97360e 100644 --- a/lib/js/src/rpc/structs/SoftButtonCapabilities.js +++ b/lib/js/src/rpc/structs/SoftButtonCapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -32,87 +33,98 @@ import { RpcStruct } from '../RpcStruct.js'; +/** + * Contains information about a SoftButton's capabilities. + */ class SoftButtonCapabilities extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {Boolean} shortPressAvailable - * @return {SoftButtonCapabilities} - */ - setShortPressAvailable (shortPressAvailable) { - this.setParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, shortPressAvailable); + * @param {Boolean} available - The button supports a short press. Whenever the button is pressed short, + * onButtonPressed( SHORT) will be invoked. + * @return {SoftButtonCapabilities} + */ + setShortPressAvailable (available) { + this.setParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getShortPressAvailable () { return this.getParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE); } /** - * @param {Boolean} longPressAvailable - * @return {SoftButtonCapabilities} - */ - setLongPressAvailable (longPressAvailable) { - this.setParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, longPressAvailable); + * @param {Boolean} available - The button supports a LONG press. Whenever the button is pressed long, + * onButtonPressed( LONG) will be invoked. + * @return {SoftButtonCapabilities} + */ + setLongPressAvailable (available) { + this.setParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getLongPressAvailable () { return this.getParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE); } /** - * @param {Boolean} upDownAvailable - * @return {SoftButtonCapabilities} - */ - setUpDownAvailable (upDownAvailable) { - this.setParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE, upDownAvailable); + * @param {Boolean} available - The button supports "button down" and "button up". Whenever the button is pressed, + * onButtonEvent( DOWN) will be invoked. Whenever the button is released, + * onButtonEvent( UP) will be invoked. + * @return {SoftButtonCapabilities} + */ + setUpDownAvailable (available) { + this.setParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getUpDownAvailable () { return this.getParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE); } /** - * @param {Boolean} imageSupported - * @return {SoftButtonCapabilities} - */ - setImageSupported (imageSupported) { - this.setParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED, imageSupported); + * @param {Boolean} supported - The button supports referencing a static or dynamic image. + * @return {SoftButtonCapabilities} + */ + setImageSupported (supported) { + this.setParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED, supported); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getImageSupported () { return this.getParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED); } /** - * @param {Boolean} textSupported - * @return {SoftButtonCapabilities} - */ - setTextSupported (textSupported) { - this.setParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED, textSupported); + * @param {Boolean} supported - The button supports the use of text. If not included, the default value should be + * considered true that the button will support text. + * @return {SoftButtonCapabilities} + */ + setTextSupported (supported) { + this.setParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED, supported); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getTextSupported () { return this.getParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED); } @@ -124,4 +136,4 @@ SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable'; SoftButtonCapabilities.KEY_IMAGE_SUPPORTED = 'imageSupported'; SoftButtonCapabilities.KEY_TEXT_SUPPORTED = 'textSupported'; -export { SoftButtonCapabilities }; +export { SoftButtonCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/StartTime.js b/lib/js/src/rpc/structs/StartTime.js new file mode 100644 index 00000000..d046ff64 --- /dev/null +++ b/lib/js/src/rpc/structs/StartTime.js @@ -0,0 +1,98 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class StartTime extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} hours - The hour of the media clock. Some radios only support a max of 19 hours. If out of range, + * it will be rejected. + * @return {StartTime} + */ + setHours (hours) { + this.setParameter(StartTime.KEY_HOURS, hours); + return this; + } + + /** + * @return {Number} + */ + getHours () { + return this.getParameter(StartTime.KEY_HOURS); + } + + /** + * @param {Number} minutes + * @return {StartTime} + */ + setMinutes (minutes) { + this.setParameter(StartTime.KEY_MINUTES, minutes); + return this; + } + + /** + * @return {Number} + */ + getMinutes () { + return this.getParameter(StartTime.KEY_MINUTES); + } + + /** + * @param {Number} seconds + * @return {StartTime} + */ + setSeconds (seconds) { + this.setParameter(StartTime.KEY_SECONDS, seconds); + return this; + } + + /** + * @return {Number} + */ + getSeconds () { + return this.getParameter(StartTime.KEY_SECONDS); + } +} + +StartTime.KEY_HOURS = 'hours'; +StartTime.KEY_MINUTES = 'minutes'; +StartTime.KEY_SECONDS = 'seconds'; + +export { StartTime }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/StationIDNumber.js b/lib/js/src/rpc/structs/StationIDNumber.js new file mode 100644 index 00000000..c952db81 --- /dev/null +++ b/lib/js/src/rpc/structs/StationIDNumber.js @@ -0,0 +1,81 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class StationIDNumber extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} code - Binary Representation of ITU Country Code. USA Code is 001. + * @return {StationIDNumber} + */ + setCountryCode (code) { + this.setParameter(StationIDNumber.KEY_COUNTRY_CODE, code); + return this; + } + + /** + * @return {Number} + */ + getCountryCode () { + return this.getParameter(StationIDNumber.KEY_COUNTRY_CODE); + } + + /** + * @param {Number} id - Binary representation of unique facility ID assigned by the FCC; FCC controlled for U.S. + * territory + * @return {StationIDNumber} + */ + setFccFacilityId (id) { + this.setParameter(StationIDNumber.KEY_FCC_FACILITY_ID, id); + return this; + } + + /** + * @return {Number} + */ + getFccFacilityId () { + return this.getParameter(StationIDNumber.KEY_FCC_FACILITY_ID); + } +} + +StationIDNumber.KEY_COUNTRY_CODE = 'countryCode'; +StationIDNumber.KEY_FCC_FACILITY_ID = 'fccFacilityId'; + +export { StationIDNumber }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/SystemCapability.js b/lib/js/src/rpc/structs/SystemCapability.js new file mode 100644 index 00000000..270614a7 --- /dev/null +++ b/lib/js/src/rpc/structs/SystemCapability.js @@ -0,0 +1,206 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { VideoStreamingCapability } from './VideoStreamingCapability.js'; +import { PhoneCapability } from './PhoneCapability.js'; +import { DisplayCapability } from './DisplayCapability.js'; +import { RemoteControlCapabilities } from './RemoteControlCapabilities.js'; +import { SeatLocationCapability } from './SeatLocationCapability.js'; +import { SystemCapabilityType } from '../enums/SystemCapabilityType.js'; +import { AppServicesCapabilities } from './AppServicesCapabilities.js'; +import { NavigationCapability } from './NavigationCapability.js'; +import { RpcStruct } from '../RpcStruct.js'; + +/** + * The systemCapabilityType identifies which data object exists in this struct. For example, if the SystemCapability + * Type is NAVIGATION then a "navigationCapability" should exist + */ +class SystemCapability extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {SystemCapabilityType} type - Used as a descriptor of what data to expect in this struct. The + * corresponding param to this enum should be included and the only other param + * included. + * @return {SystemCapability} + */ + setSystemCapabilityType (type) { + this.validateType(SystemCapabilityType, type); + this.setParameter(SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE, type); + return this; + } + + /** + * @return {SystemCapabilityType} + */ + getSystemCapabilityType () { + return this.getObject(SystemCapabilityType, SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE); + } + + /** + * @param {NavigationCapability} capability - Describes extended capabilities for onboard navigation system + * @return {SystemCapability} + */ + setNavigationCapability (capability) { + this.validateType(NavigationCapability, capability); + this.setParameter(SystemCapability.KEY_NAVIGATION_CAPABILITY, capability); + return this; + } + + /** + * @return {NavigationCapability} + */ + getNavigationCapability () { + return this.getObject(NavigationCapability, SystemCapability.KEY_NAVIGATION_CAPABILITY); + } + + /** + * @param {PhoneCapability} capability - Describes extended capabilities of the module's phone feature + * @return {SystemCapability} + */ + setPhoneCapability (capability) { + this.validateType(PhoneCapability, capability); + this.setParameter(SystemCapability.KEY_PHONE_CAPABILITY, capability); + return this; + } + + /** + * @return {PhoneCapability} + */ + getPhoneCapability () { + return this.getObject(PhoneCapability, SystemCapability.KEY_PHONE_CAPABILITY); + } + + /** + * @param {VideoStreamingCapability} capability - Describes extended capabilities of the module's phone feature + * @return {SystemCapability} + */ + setVideoStreamingCapability (capability) { + this.validateType(VideoStreamingCapability, capability); + this.setParameter(SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY, capability); + return this; + } + + /** + * @return {VideoStreamingCapability} + */ + getVideoStreamingCapability () { + return this.getObject(VideoStreamingCapability, SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY); + } + + /** + * @param {RemoteControlCapabilities} capability - Describes extended capabilities of the module's phone feature + * @return {SystemCapability} + */ + setRemoteControlCapability (capability) { + this.validateType(RemoteControlCapabilities, capability); + this.setParameter(SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY, capability); + return this; + } + + /** + * @return {RemoteControlCapabilities} + */ + getRemoteControlCapability () { + return this.getObject(RemoteControlCapabilities, SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY); + } + + /** + * @param {AppServicesCapabilities} capabilities - An array of currently available services. If this is an update to + * the capability the affected services will include an update + * reason in that item + * @return {SystemCapability} + */ + setAppServicesCapabilities (capabilities) { + this.validateType(AppServicesCapabilities, capabilities); + this.setParameter(SystemCapability.KEY_APP_SERVICES_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {AppServicesCapabilities} + */ + getAppServicesCapabilities () { + return this.getObject(AppServicesCapabilities, SystemCapability.KEY_APP_SERVICES_CAPABILITIES); + } + + /** + * @param {SeatLocationCapability} capability - Contains information about the locations of each seat + * @return {SystemCapability} + */ + setSeatLocationCapability (capability) { + this.validateType(SeatLocationCapability, capability); + this.setParameter(SystemCapability.KEY_SEAT_LOCATION_CAPABILITY, capability); + return this; + } + + /** + * @return {SeatLocationCapability} + */ + getSeatLocationCapability () { + return this.getObject(SeatLocationCapability, SystemCapability.KEY_SEAT_LOCATION_CAPABILITY); + } + + /** + * @param {DisplayCapability[]} capabilities + * @return {SystemCapability} + */ + setDisplayCapabilities (capabilities) { + this.validateType(DisplayCapability, capabilities, true); + this.setParameter(SystemCapability.KEY_DISPLAY_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {DisplayCapability[]} + */ + getDisplayCapabilities () { + return this.getObject(DisplayCapability, SystemCapability.KEY_DISPLAY_CAPABILITIES); + } +} + +SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE = 'systemCapabilityType'; +SystemCapability.KEY_NAVIGATION_CAPABILITY = 'navigationCapability'; +SystemCapability.KEY_PHONE_CAPABILITY = 'phoneCapability'; +SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY = 'videoStreamingCapability'; +SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY = 'remoteControlCapability'; +SystemCapability.KEY_APP_SERVICES_CAPABILITIES = 'appServicesCapabilities'; +SystemCapability.KEY_SEAT_LOCATION_CAPABILITY = 'seatLocationCapability'; +SystemCapability.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities'; + +export { SystemCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TTSChunk.js b/lib/js/src/rpc/structs/TTSChunk.js index f9f299ff..d63a55d4 100644 --- a/lib/js/src/rpc/structs/TTSChunk.js +++ b/lib/js/src/rpc/structs/TTSChunk.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,41 +34,48 @@ import { RpcStruct } from '../RpcStruct.js'; import { SpeechCapabilities } from '../enums/SpeechCapabilities.js'; +/** + * A TTS chunk, that consists of text/phonemes to speak or the name of a file to play, and a TTS type (like text or + * SAPI) + */ class TTSChunk extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {String} text - * @return {TTSChunk} - */ + * @param {String} text - The text or phonemes to speak, or the name of the audio file to play. May not be empty. + * @return {TTSChunk} + */ setText (text) { this.setParameter(TTSChunk.KEY_TEXT, text); return this; } /** - * @return {Number} - */ + * @return {String} + */ getText () { return this.getParameter(TTSChunk.KEY_TEXT); } /** - * @param {SpeechCapabilities} type - * @return {TTSChunk} - */ + * @param {SpeechCapabilities} type - Describes whether the TTS chunk is plain text, a specific phoneme set, or an + * audio file. See SpeechCapabilities + * @return {TTSChunk} + */ setType (type) { this.validateType(SpeechCapabilities, type); - this.setParameter(TTSChunk.KEY_TYPE, type); return this; } /** - * @return {SpeechCapabilities} - */ + * @return {SpeechCapabilities} + */ getType () { return this.getObject(SpeechCapabilities, TTSChunk.KEY_TYPE); } @@ -76,4 +84,4 @@ class TTSChunk extends RpcStruct { TTSChunk.KEY_TEXT = 'text'; TTSChunk.KEY_TYPE = 'type'; -export { TTSChunk }; +export { TTSChunk }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/Temperature.js b/lib/js/src/rpc/structs/Temperature.js new file mode 100644 index 00000000..692ce7c0 --- /dev/null +++ b/lib/js/src/rpc/structs/Temperature.js @@ -0,0 +1,83 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { TemperatureUnit } from '../enums/TemperatureUnit.js'; + +class Temperature extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {TemperatureUnit} unit - Temperature Unit + * @return {Temperature} + */ + setUnit (unit) { + this.validateType(TemperatureUnit, unit); + this.setParameter(Temperature.KEY_UNIT, unit); + return this; + } + + /** + * @return {TemperatureUnit} + */ + getUnit () { + return this.getObject(TemperatureUnit, Temperature.KEY_UNIT); + } + + /** + * @param {Number} value - Temperature Value in TemperatureUnit specified unit. Range depends on OEM and is not + * checked by SDL. + * @return {Temperature} + */ + setValue (value) { + this.setParameter(Temperature.KEY_VALUE, value); + return this; + } + + /** + * @return {Number} + */ + getValue () { + return this.getParameter(Temperature.KEY_VALUE); + } +} + +Temperature.KEY_UNIT = 'unit'; +Temperature.KEY_VALUE = 'value'; + +export { Temperature }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TemplateColorScheme.js b/lib/js/src/rpc/structs/TemplateColorScheme.js index bc84641f..a6a26587 100644 --- a/lib/js/src/rpc/structs/TemplateColorScheme.js +++ b/lib/js/src/rpc/structs/TemplateColorScheme.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,61 +34,64 @@ import { RpcStruct } from '../RpcStruct.js'; import { RGBColor } from './RGBColor.js'; +/** + * A color scheme for all display layout templates. + */ class TemplateColorScheme extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {RGBColor} primaryColor - * @return {TemplateColorScheme} - */ - setPrimaryColor (primaryColor) { - this.validateType(RGBColor, primaryColor); - - this.setParameter(TemplateColorScheme.KEY_PRIMARY_COLOR, primaryColor); + * @param {RGBColor} color - The primary "accent" color + * @return {TemplateColorScheme} + */ + setPrimaryColor (color) { + this.validateType(RGBColor, color); + this.setParameter(TemplateColorScheme.KEY_PRIMARY_COLOR, color); return this; } /** - * @return {RGBColor} - */ + * @return {RGBColor} + */ getPrimaryColor () { return this.getObject(RGBColor, TemplateColorScheme.KEY_PRIMARY_COLOR); } /** - * @param {RGBColor} secondaryColor - * @return {TemplateColorScheme} - */ - setSecondaryColor (secondaryColor) { - this.validateType(RGBColor, secondaryColor); - - this.setParameter(TemplateColorScheme.KEY_SECONDARY_COLOR, secondaryColor); + * @param {RGBColor} color - The secondary "accent" color + * @return {TemplateColorScheme} + */ + setSecondaryColor (color) { + this.validateType(RGBColor, color); + this.setParameter(TemplateColorScheme.KEY_SECONDARY_COLOR, color); return this; } /** - * @return {RGBColor} - */ + * @return {RGBColor} + */ getSecondaryColor () { return this.getObject(RGBColor, TemplateColorScheme.KEY_SECONDARY_COLOR); } /** - * @param {RGBColor} backgroundColor - * @return {TemplateColorScheme} - */ - setBackgroundColor (backgroundColor) { - this.validateType(RGBColor, backgroundColor); - - this.setParameter(TemplateColorScheme.KEY_BACKGROUND_COLOR, backgroundColor); + * @param {RGBColor} color - The color of the background + * @return {TemplateColorScheme} + */ + setBackgroundColor (color) { + this.validateType(RGBColor, color); + this.setParameter(TemplateColorScheme.KEY_BACKGROUND_COLOR, color); return this; } /** - * @return {RGBColor} - */ + * @return {RGBColor} + */ getBackgroundColor () { return this.getObject(RGBColor, TemplateColorScheme.KEY_BACKGROUND_COLOR); } @@ -97,4 +101,4 @@ TemplateColorScheme.KEY_PRIMARY_COLOR = 'primaryColor'; TemplateColorScheme.KEY_SECONDARY_COLOR = 'secondaryColor'; TemplateColorScheme.KEY_BACKGROUND_COLOR = 'backgroundColor'; -export { TemplateColorScheme }; +export { TemplateColorScheme }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TemplateConfiguration.js b/lib/js/src/rpc/structs/TemplateConfiguration.js new file mode 100644 index 00000000..a63db77e --- /dev/null +++ b/lib/js/src/rpc/structs/TemplateConfiguration.js @@ -0,0 +1,101 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { TemplateColorScheme } from './TemplateColorScheme.js'; + +class TemplateConfiguration extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} template - Predefined or dynamically created window template. Currently only predefined window + * template layouts are defined. + * @return {TemplateConfiguration} + */ + setTemplate (template) { + this.setParameter(TemplateConfiguration.KEY_TEMPLATE, template); + return this; + } + + /** + * @return {String} + */ + getTemplate () { + return this.getParameter(TemplateConfiguration.KEY_TEMPLATE); + } + + /** + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {TemplateConfiguration} + */ + setDayColorScheme (scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(TemplateConfiguration.KEY_DAY_COLOR_SCHEME, scheme); + return this; + } + + /** + * @return {TemplateColorScheme} + */ + getDayColorScheme () { + return this.getObject(TemplateColorScheme, TemplateConfiguration.KEY_DAY_COLOR_SCHEME); + } + + /** + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {TemplateConfiguration} + */ + setNightColorScheme (scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME, scheme); + return this; + } + + /** + * @return {TemplateColorScheme} + */ + getNightColorScheme () { + return this.getObject(TemplateColorScheme, TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME); + } +} + +TemplateConfiguration.KEY_TEMPLATE = 'template'; +TemplateConfiguration.KEY_DAY_COLOR_SCHEME = 'dayColorScheme'; +TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme'; + +export { TemplateConfiguration }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TextField.js b/lib/js/src/rpc/structs/TextField.js index bb2332f9..4f7d4d72 100644 --- a/lib/js/src/rpc/structs/TextField.js +++ b/lib/js/src/rpc/structs/TextField.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -30,80 +31,80 @@ * POSSIBILITY OF SUCH DAMAGE. */ -import { RpcStruct } from '../RpcStruct.js'; import { TextFieldName } from '../enums/TextFieldName.js'; import { CharacterSet } from '../enums/CharacterSet.js'; +import { RpcStruct } from '../RpcStruct.js'; class TextField extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {TextFieldName} textFieldName - * @return {TextField} - */ - setTextFieldName (textFieldName) { - this.validateType(TextFieldName, textFieldName); - - this.setParameter(TextField.KEY_NAME, textFieldName); + * @param {TextFieldName} name - The name that identifies the field. See TextFieldName. + * @return {TextField} + */ + setName (name) { + this.validateType(TextFieldName, name); + this.setParameter(TextField.KEY_NAME, name); return this; } /** - * @return {TextFieldName} - */ - getTextFieldName () { + * @return {TextFieldName} + */ + getName () { return this.getObject(TextFieldName, TextField.KEY_NAME); } - /** - * @param {CharacterSet} textFieldName - * @return {TextField} - */ - setCharacterSet (characterSet) { - this.validateType(CharacterSet, characterSet); - - this.setParameter(TextField.KEY_CHARACTER_SET, characterSet); + * @param {CharacterSet} set - The character set that is supported in this field. See CharacterSet. + * @return {TextField} + */ + setCharacterSet (set) { + this.validateType(CharacterSet, set); + this.setParameter(TextField.KEY_CHARACTER_SET, set); return this; } /** - * @return {CharacterSet} - */ + * @return {CharacterSet} + */ getCharacterSet () { return this.getObject(CharacterSet, TextField.KEY_CHARACTER_SET); } /** - * @param {Number} width - * @return {TextField} - */ + * @param {Number} width - The number of characters in one row of this field. + * @return {TextField} + */ setWidth (width) { this.setParameter(TextField.KEY_WIDTH, width); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getWidth () { return this.getParameter(TextField.KEY_WIDTH); } /** - * @param {Number} rows - * @return {TextField} - */ + * @param {Number} rows - The number of rows of this field. + * @return {TextField} + */ setRows (rows) { this.setParameter(TextField.KEY_ROWS, rows); return this; } /** - * @return {Number} - */ + * @return {Number} + */ getRows () { return this.getParameter(TextField.KEY_ROWS); } @@ -114,4 +115,4 @@ TextField.KEY_CHARACTER_SET = 'characterSet'; TextField.KEY_WIDTH = 'width'; TextField.KEY_ROWS = 'rows'; -export { TextField }; +export { TextField }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TireStatus.js b/lib/js/src/rpc/structs/TireStatus.js new file mode 100644 index 00000000..183c7182 --- /dev/null +++ b/lib/js/src/rpc/structs/TireStatus.js @@ -0,0 +1,177 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { SingleTireStatus } from './SingleTireStatus.js'; +import { WarningLightStatus } from '../enums/WarningLightStatus.js'; + +/** + * The status and pressure of the tires. + */ +class TireStatus extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {WarningLightStatus} telltale - Status of the Tire Pressure Telltale. See WarningLightStatus. + * @return {TireStatus} + */ + setPressureTelltale (telltale) { + this.validateType(WarningLightStatus, telltale); + this.setParameter(TireStatus.KEY_PRESSURE_TELLTALE, telltale); + return this; + } + + /** + * @return {WarningLightStatus} + */ + getPressureTelltale () { + return this.getObject(WarningLightStatus, TireStatus.KEY_PRESSURE_TELLTALE); + } + + /** + * @param {SingleTireStatus} front - The status of the left front tire. + * @return {TireStatus} + */ + setLeftFront (front) { + this.validateType(SingleTireStatus, front); + this.setParameter(TireStatus.KEY_LEFT_FRONT, front); + return this; + } + + /** + * @return {SingleTireStatus} + */ + getLeftFront () { + return this.getObject(SingleTireStatus, TireStatus.KEY_LEFT_FRONT); + } + + /** + * @param {SingleTireStatus} front - The status of the right front tire. + * @return {TireStatus} + */ + setRightFront (front) { + this.validateType(SingleTireStatus, front); + this.setParameter(TireStatus.KEY_RIGHT_FRONT, front); + return this; + } + + /** + * @return {SingleTireStatus} + */ + getRightFront () { + return this.getObject(SingleTireStatus, TireStatus.KEY_RIGHT_FRONT); + } + + /** + * @param {SingleTireStatus} rear - The status of the left rear tire. + * @return {TireStatus} + */ + setLeftRear (rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_LEFT_REAR, rear); + return this; + } + + /** + * @return {SingleTireStatus} + */ + getLeftRear () { + return this.getObject(SingleTireStatus, TireStatus.KEY_LEFT_REAR); + } + + /** + * @param {SingleTireStatus} rear - The status of the right rear tire. + * @return {TireStatus} + */ + setRightRear (rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_RIGHT_REAR, rear); + return this; + } + + /** + * @return {SingleTireStatus} + */ + getRightRear () { + return this.getObject(SingleTireStatus, TireStatus.KEY_RIGHT_REAR); + } + + /** + * @param {SingleTireStatus} rear - The status of the inner left rear. + * @return {TireStatus} + */ + setInnerLeftRear (rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_INNER_LEFT_REAR, rear); + return this; + } + + /** + * @return {SingleTireStatus} + */ + getInnerLeftRear () { + return this.getObject(SingleTireStatus, TireStatus.KEY_INNER_LEFT_REAR); + } + + /** + * @param {SingleTireStatus} rear - The status of the inner right rear. + * @return {TireStatus} + */ + setInnerRightRear (rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_INNER_RIGHT_REAR, rear); + return this; + } + + /** + * @return {SingleTireStatus} + */ + getInnerRightRear () { + return this.getObject(SingleTireStatus, TireStatus.KEY_INNER_RIGHT_REAR); + } +} + +TireStatus.KEY_PRESSURE_TELLTALE = 'pressureTelltale'; +TireStatus.KEY_LEFT_FRONT = 'leftFront'; +TireStatus.KEY_RIGHT_FRONT = 'rightFront'; +TireStatus.KEY_LEFT_REAR = 'leftRear'; +TireStatus.KEY_RIGHT_REAR = 'rightRear'; +TireStatus.KEY_INNER_LEFT_REAR = 'innerLeftRear'; +TireStatus.KEY_INNER_RIGHT_REAR = 'innerRightRear'; + +export { TireStatus }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TouchCoord.js b/lib/js/src/rpc/structs/TouchCoord.js new file mode 100644 index 00000000..000abbc4 --- /dev/null +++ b/lib/js/src/rpc/structs/TouchCoord.js @@ -0,0 +1,80 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class TouchCoord extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} x - The x coordinate of the touch. + * @return {TouchCoord} + */ + setX (x) { + this.setParameter(TouchCoord.KEY_X, x); + return this; + } + + /** + * @return {Number} + */ + getX () { + return this.getParameter(TouchCoord.KEY_X); + } + + /** + * @param {Number} y - The y coordinate of the touch. + * @return {TouchCoord} + */ + setY (y) { + this.setParameter(TouchCoord.KEY_Y, y); + return this; + } + + /** + * @return {Number} + */ + getY () { + return this.getParameter(TouchCoord.KEY_Y); + } +} + +TouchCoord.KEY_X = 'x'; +TouchCoord.KEY_Y = 'y'; + +export { TouchCoord }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TouchEvent.js b/lib/js/src/rpc/structs/TouchEvent.js new file mode 100644 index 00000000..d1558d4a --- /dev/null +++ b/lib/js/src/rpc/structs/TouchEvent.js @@ -0,0 +1,106 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { TouchCoord } from './TouchCoord.js'; + +class TouchEvent extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} id - A touch's unique identifier. The application can track the current touch events by id. If a + * touch event has type begin, the id should be added to the set of touches. If a touch event + * has type end, the id should be removed from the set of touches. + * @return {TouchEvent} + */ + setId (id) { + this.setParameter(TouchEvent.KEY_ID, id); + return this; + } + + /** + * @return {Number} + */ + getId () { + return this.getParameter(TouchEvent.KEY_ID); + } + + /** + * @param {Number[]} ts - The time that the touch was recorded. This number can the time since the beginning of the + * session or something else as long as the units are in milliseconds. The timestamp is used + * to determined the rate of change of position of a touch. The application also uses the + * time to verify whether two touches, with different ids, are part of a single action by the + * user. If there is only a single timestamp in this array, it is the same for every + * coordinate in the coordinates array. + * @return {TouchEvent} + */ + setTs (ts) { + this.setParameter(TouchEvent.KEY_TS, ts); + return this; + } + + /** + * @return {Number[]} + */ + getTs () { + return this.getParameter(TouchEvent.KEY_TS); + } + + /** + * @param {TouchCoord[]} c + * @return {TouchEvent} + */ + setC (c) { + this.validateType(TouchCoord, c, true); + this.setParameter(TouchEvent.KEY_C, c); + return this; + } + + /** + * @return {TouchCoord[]} + */ + getC () { + return this.getObject(TouchCoord, TouchEvent.KEY_C); + } +} + +TouchEvent.KEY_ID = 'id'; +TouchEvent.KEY_TS = 'ts'; +TouchEvent.KEY_C = 'c'; + +export { TouchEvent }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/TouchEventCapabilities.js b/lib/js/src/rpc/structs/TouchEventCapabilities.js index ab0a4760..b686d702 100644 --- a/lib/js/src/rpc/structs/TouchEventCapabilities.js +++ b/lib/js/src/rpc/structs/TouchEventCapabilities.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,57 +34,57 @@ import { RpcStruct } from '../RpcStruct.js'; class TouchEventCapabilities extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } - /** - * @param {Boolean} pressAvailable - * @return {TouchEventCapabilities} - */ - setPressAvailable (pressAvailable) { - this.setParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE, pressAvailable); + * @param {Boolean} available + * @return {TouchEventCapabilities} + */ + setPressAvailable (available) { + this.setParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getPressAvailable () { return this.getParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE); } /** - * @param {Boolean} multiTouchAvailable - * @return {TouchEventCapabilities} - */ - setMultiTouchAvailable (multiTouchAvailable) { - this.setParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE, multiTouchAvailable); + * @param {Boolean} available + * @return {TouchEventCapabilities} + */ + setMultiTouchAvailable (available) { + this.setParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getMultiTouchAvailable () { return this.getParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE); } - - /** - * @param {Boolean} doublePressAvailable - * @return {TouchEventCapabilities} - */ - setDoublePressAvailable (doublePressAvailable) { - this.setParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE, doublePressAvailable); + * @param {Boolean} available + * @return {TouchEventCapabilities} + */ + setDoublePressAvailable (available) { + this.setParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE, available); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getDoublePressAvailable () { return this.getParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE); } @@ -93,4 +94,4 @@ TouchEventCapabilities.KEY_PRESS_AVAILABLE = 'pressAvailable'; TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE = 'multiTouchAvailable'; TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE = 'doublePressAvailable'; -export { TouchEventCapabilities }; +export { TouchEventCapabilities }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/Turn.js b/lib/js/src/rpc/structs/Turn.js new file mode 100644 index 00000000..e139cbae --- /dev/null +++ b/lib/js/src/rpc/structs/Turn.js @@ -0,0 +1,82 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { Image } from './Image.js'; + +class Turn extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} text - Individual turn text. Must provide at least text or icon for a given turn. + * @return {Turn} + */ + setNavigationText (text) { + this.setParameter(Turn.KEY_NAVIGATION_TEXT, text); + return this; + } + + /** + * @return {String} + */ + getNavigationText () { + return this.getParameter(Turn.KEY_NAVIGATION_TEXT); + } + + /** + * @param {Image} icon - Individual turn icon. Must provide at least text or icon for a given turn. + * @return {Turn} + */ + setTurnIcon (icon) { + this.validateType(Image, icon); + this.setParameter(Turn.KEY_TURN_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getTurnIcon () { + return this.getObject(Image, Turn.KEY_TURN_ICON); + } +} + +Turn.KEY_NAVIGATION_TEXT = 'navigationText'; +Turn.KEY_TURN_ICON = 'turnIcon'; + +export { Turn }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/VehicleDataResult.js b/lib/js/src/rpc/structs/VehicleDataResult.js new file mode 100644 index 00000000..700e29b3 --- /dev/null +++ b/lib/js/src/rpc/structs/VehicleDataResult.js @@ -0,0 +1,104 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { VehicleDataResultCode } from '../enums/VehicleDataResultCode.js'; +import { VehicleDataType } from '../enums/VehicleDataType.js'; + +/** + * Individual published data request result + */ +class VehicleDataResult extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {VehicleDataType} type - Defined published data element type. + * @return {VehicleDataResult} + */ + setDataType (type) { + this.validateType(VehicleDataType, type); + this.setParameter(VehicleDataResult.KEY_DATA_TYPE, type); + return this; + } + + /** + * @return {VehicleDataType} + */ + getDataType () { + return this.getObject(VehicleDataType, VehicleDataResult.KEY_DATA_TYPE); + } + + /** + * @param {VehicleDataResultCode} code - Published data result code. + * @return {VehicleDataResult} + */ + setResultCode (code) { + this.validateType(VehicleDataResultCode, code); + this.setParameter(VehicleDataResult.KEY_RESULT_CODE, code); + return this; + } + + /** + * @return {VehicleDataResultCode} + */ + getResultCode () { + return this.getObject(VehicleDataResultCode, VehicleDataResult.KEY_RESULT_CODE); + } + + /** + * @param {String} type - Type of requested oem specific parameter + * @return {VehicleDataResult} + */ + setOemCustomDataType (type) { + this.setParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getOemCustomDataType () { + return this.getParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE); + } +} + +VehicleDataResult.KEY_DATA_TYPE = 'dataType'; +VehicleDataResult.KEY_RESULT_CODE = 'resultCode'; +VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE = 'oemCustomDataType'; + +export { VehicleDataResult }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/VehicleType.js b/lib/js/src/rpc/structs/VehicleType.js index d80b4e92..ce4b3ff1 100644 --- a/lib/js/src/rpc/structs/VehicleType.js +++ b/lib/js/src/rpc/structs/VehicleType.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -33,71 +34,73 @@ import { RpcStruct } from '../RpcStruct.js'; class VehicleType extends RpcStruct { + /** + * @constructor + */ constructor (parameters) { super(parameters); } /** - * @param {String} make - * @return {VehicleType} - */ + * @param {String} make - Make of the vehicle, e.g. Ford + * @return {VehicleType} + */ setMake (make) { this.setParameter(VehicleType.KEY_MAKE, make); return this; } /** - * @return {String} - */ + * @return {String} + */ getMake () { return this.getParameter(VehicleType.KEY_MAKE); } /** - * @param {String} model - * @return {VehicleType} - */ + * @param {String} model - Model of the vehicle, e.g. Fiesta + * @return {VehicleType} + */ setModel (model) { this.setParameter(VehicleType.KEY_MODEL, model); return this; } /** - * @return {String} - */ + * @return {String} + */ getModel () { return this.getParameter(VehicleType.KEY_MODEL); } /** - * @param {String} modelYear - * @return {VehicleType} - */ - setModelYear (modelYear) { - this.setParameter(VehicleType.KEY_MODEL_YEAR, modelYear); + * @param {String} year - Model Year of the vehicle, e.g. 2013 + * @return {VehicleType} + */ + setModelYear (year) { + this.setParameter(VehicleType.KEY_MODEL_YEAR, year); return this; } /** - * @return {String} - */ + * @return {String} + */ getModelYear () { return this.getParameter(VehicleType.KEY_MODEL_YEAR); } - /** - * @param {String} trim - * @return {VehicleType} - */ + * @param {String} trim - Trim of the vehicle, e.g. SE + * @return {VehicleType} + */ setTrim (trim) { this.setParameter(VehicleType.KEY_TRIM, trim); return this; } /** - * @return {String} - */ + * @return {String} + */ getTrim () { return this.getParameter(VehicleType.KEY_TRIM); } @@ -108,4 +111,4 @@ VehicleType.KEY_MODEL = 'model'; VehicleType.KEY_MODEL_YEAR = 'modelYear'; VehicleType.KEY_TRIM = 'trim'; -export { VehicleType }; +export { VehicleType }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/VideoStreamingCapability.js b/lib/js/src/rpc/structs/VideoStreamingCapability.js index 345584da..73ab6b1c 100644 --- a/lib/js/src/rpc/structs/VideoStreamingCapability.js +++ b/lib/js/src/rpc/structs/VideoStreamingCapability.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -31,127 +32,136 @@ */ import { RpcStruct } from '../RpcStruct.js'; -import { VideoStreamingFormat } from './VideoStreamingFormat.js'; import { ImageResolution } from './ImageResolution.js'; +import { VideoStreamingFormat } from './VideoStreamingFormat.js'; +/** + * Contains information about this system's video streaming capabilities. + */ class VideoStreamingCapability extends RpcStruct { /** - * @constructor - */ - constructor () { - super(); + * @constructor + */ + constructor (parameters) { + super(parameters); } /** - * @param {ImageResolution} val - * @return {VideoStreamingCapability} - */ - setPreferredResolution (val) { - this.validateType(ImageResolution, val); - this.setParameter(VideoStreamingCapability.KEY_PREFERRED_RESOLUTION, val); + * @param {ImageResolution} resolution - The preferred resolution of a video stream for decoding and rendering on + * HMI. + * @return {VideoStreamingCapability} + */ + setPreferredResolution (resolution) { + this.validateType(ImageResolution, resolution); + this.setParameter(VideoStreamingCapability.KEY_PREFERRED_RESOLUTION, resolution); return this; } /** - * @return {ImageResolution} - */ + * @return {ImageResolution} + */ getPreferredResolution () { return this.getObject(ImageResolution, VideoStreamingCapability.KEY_PREFERRED_RESOLUTION); } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ - setMaxBitrate (val) { - this.setParameter(VideoStreamingCapability.KEY_MAX_BITRATE, val); + * @param {Number} bitrate - The maximum bitrate of video stream that is supported, in kbps. + * @return {VideoStreamingCapability} + */ + setMaxBitrate (bitrate) { + this.setParameter(VideoStreamingCapability.KEY_MAX_BITRATE, bitrate); return this; } /** - * @return {number} - */ + * @return {Number} + */ getMaxBitrate () { return this.getParameter(VideoStreamingCapability.KEY_MAX_BITRATE); } - /** - * @param {VideoStreamingFormat[]} val - * @return {VideoStreamingCapability} - */ - setSupportedFormats (val) { - this.validateType(VideoStreamingFormat, val, true); - this.setParameter(VideoStreamingCapability.KEY_SUPPORTED_FORMATS, val); + * @param {VideoStreamingFormat[]} formats - Detailed information on each format supported by this system, in its + * preferred order (i.e. the first element in the array is most preferable + * to the system). Each object will contain a VideoStreamingFormat that + * describes what can be expected. + * @return {VideoStreamingCapability} + */ + setSupportedFormats (formats) { + this.validateType(VideoStreamingFormat, formats, true); + this.setParameter(VideoStreamingCapability.KEY_SUPPORTED_FORMATS, formats); + return this; } /** - * @return {VideoStreamingFormat[]} - */ + * @return {VideoStreamingFormat[]} + */ getSupportedFormats () { return this.getObject(VideoStreamingFormat, VideoStreamingCapability.KEY_SUPPORTED_FORMATS); } /** - * @param {Boolean} val - * @return {VideoStreamingCapability} - */ - setHapticSpatialDataSupported (val) { - this.setParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED, val); + * @param {Boolean} supported - True if the system can utilize the haptic spatial data from the source being + * streamed. If not included, it can be assumed the module doesn't support haptic + * spatial data'. + * @return {VideoStreamingCapability} + */ + setHapticSpatialDataSupported (supported) { + this.setParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED, supported); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getHapticSpatialDataSupported () { return this.getParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED); } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ - setDiagonalScreenSize (val) { - this.setParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE, val); + * @param {Number} size - The diagonal screen size in inches. + * @return {VideoStreamingCapability} + */ + setDiagonalScreenSize (size) { + this.setParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE, size); return this; } /** - * @return {number} - */ + * @return {Number} + */ getDiagonalScreenSize () { return this.getParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE); } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ - setPixelPerInch (val) { - this.setParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH, val); + * @param {Number} inch - PPI is the diagonal resolution in pixels divided by the diagonal screen size in inches. + * @return {VideoStreamingCapability} + */ + setPixelPerInch (inch) { + this.setParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH, inch); return this; } /** - * @return {number} - */ + * @return {Number} + */ getPixelPerInch () { return this.getParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH); } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ - setScale (val) { - this.setParameter(VideoStreamingCapability.KEY_SCALE, val); + * @param {Number} scale - The scaling factor the app should use to change the size of the projecting view. + * @return {VideoStreamingCapability} + */ + setScale (scale) { + this.setParameter(VideoStreamingCapability.KEY_SCALE, scale); return this; } /** - * @return {number} - */ + * @return {Number} + */ getScale () { return this.getParameter(VideoStreamingCapability.KEY_SCALE); } @@ -165,4 +175,4 @@ VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE = 'diagonalScreenSize'; VideoStreamingCapability.KEY_PIXEL_PER_INCH = 'pixelPerInch'; VideoStreamingCapability.KEY_SCALE = 'scale'; -export { VideoStreamingCapability }; +export { VideoStreamingCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/VideoStreamingFormat.js b/lib/js/src/rpc/structs/VideoStreamingFormat.js index ede6a114..22520c62 100644 --- a/lib/js/src/rpc/structs/VideoStreamingFormat.js +++ b/lib/js/src/rpc/structs/VideoStreamingFormat.js @@ -1,5 +1,6 @@ +/* eslint-disable camelcase */ /* -* Copyright (c) 2019, Livio, Inc. +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -13,9 +14,9 @@ * disclaimer in the documentation and/or other materials provided with the * distribution. * -* Neither the name of the Livio Inc. nor the names of its contributors -* may be used to endorse or promote products derived from this software -* without specific prior written permission. +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -31,52 +32,56 @@ */ import { RpcStruct } from '../RpcStruct.js'; -import { VideoStreamingProtocol } from '../enums/VideoStreamingProtocol.js'; import { VideoStreamingCodec } from '../enums/VideoStreamingCodec.js'; +import { VideoStreamingProtocol } from '../enums/VideoStreamingProtocol.js'; +/** + * Video streaming formats and their specifications. + */ class VideoStreamingFormat extends RpcStruct { /** - * @constructor - */ - constructor () { - super(); + * @constructor + */ + constructor (parameters) { + super(parameters); } + /** - * @param {VideoStreamingProtocol} val - * @return {VideoStreamingFormat} - */ - setProtocol (val) { - this.validateType(VideoStreamingProtocol, val); - this.setParameter(VideoStreamingFormat.KEY_PROTOCOL, val); + * @param {VideoStreamingProtocol} protocol - Protocol type, see VideoStreamingProtocol + * @return {VideoStreamingFormat} + */ + setProtocol (protocol) { + this.validateType(VideoStreamingProtocol, protocol); + this.setParameter(VideoStreamingFormat.KEY_PROTOCOL, protocol); return this; } /** - * @return {VideoStreamingProtocol} - */ + * @return {VideoStreamingProtocol} + */ getProtocol () { - return this.getParameter(VideoStreamingFormat.KEY_PROTOCOL); + return this.getObject(VideoStreamingProtocol, VideoStreamingFormat.KEY_PROTOCOL); } /** - * @param {VideoStreamingCodec} val - * @return {VideoStreamingFormat} - */ - setCodec (val) { - this.validateType(VideoStreamingCodec, val); - this.setParameter(VideoStreamingFormat.KEY_CODEC, val); + * @param {VideoStreamingCodec} codec - Codec type, see VideoStreamingCodec + * @return {VideoStreamingFormat} + */ + setCodec (codec) { + this.validateType(VideoStreamingCodec, codec); + this.setParameter(VideoStreamingFormat.KEY_CODEC, codec); return this; } /** - * @return {VideoStreamingCodec} - */ + * @return {VideoStreamingCodec} + */ getCodec () { - return this.getParameter(VideoStreamingFormat.KEY_CODEC); + return this.getObject(VideoStreamingCodec, VideoStreamingFormat.KEY_CODEC); } } VideoStreamingFormat.KEY_PROTOCOL = 'protocol'; VideoStreamingFormat.KEY_CODEC = 'codec'; -export { VideoStreamingFormat }; +export { VideoStreamingFormat }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/VrHelpItem.js b/lib/js/src/rpc/structs/VrHelpItem.js new file mode 100644 index 00000000..8103308c --- /dev/null +++ b/lib/js/src/rpc/structs/VrHelpItem.js @@ -0,0 +1,99 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; +import { Image } from './Image.js'; + +class VrHelpItem extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} text - Text to display for VR Help item + * @return {VrHelpItem} + */ + setText (text) { + this.setParameter(VrHelpItem.KEY_TEXT, text); + return this; + } + + /** + * @return {String} + */ + getText () { + return this.getParameter(VrHelpItem.KEY_TEXT); + } + + /** + * @param {Image} image - Image struct for VR Help item + * @return {VrHelpItem} + */ + setImage (image) { + this.validateType(Image, image); + this.setParameter(VrHelpItem.KEY_IMAGE, image); + return this; + } + + /** + * @return {Image} + */ + getImage () { + return this.getObject(Image, VrHelpItem.KEY_IMAGE); + } + + /** + * @param {Number} position - Position to display item in VR Help list + * @return {VrHelpItem} + */ + setPosition (position) { + this.setParameter(VrHelpItem.KEY_POSITION, position); + return this; + } + + /** + * @return {Number} + */ + getPosition () { + return this.getParameter(VrHelpItem.KEY_POSITION); + } +} + +VrHelpItem.KEY_TEXT = 'text'; +VrHelpItem.KEY_IMAGE = 'image'; +VrHelpItem.KEY_POSITION = 'position'; + +export { VrHelpItem }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/WeatherAlert.js b/lib/js/src/rpc/structs/WeatherAlert.js new file mode 100644 index 00000000..6520340b --- /dev/null +++ b/lib/js/src/rpc/structs/WeatherAlert.js @@ -0,0 +1,151 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { DateTime } from './DateTime.js'; +import { RpcStruct } from '../RpcStruct.js'; + +class WeatherAlert extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {String} title + * @return {WeatherAlert} + */ + setTitle (title) { + this.setParameter(WeatherAlert.KEY_TITLE, title); + return this; + } + + /** + * @return {String} + */ + getTitle () { + return this.getParameter(WeatherAlert.KEY_TITLE); + } + + /** + * @param {String} summary + * @return {WeatherAlert} + */ + setSummary (summary) { + this.setParameter(WeatherAlert.KEY_SUMMARY, summary); + return this; + } + + /** + * @return {String} + */ + getSummary () { + return this.getParameter(WeatherAlert.KEY_SUMMARY); + } + + /** + * @param {DateTime} expires + * @return {WeatherAlert} + */ + setExpires (expires) { + this.validateType(DateTime, expires); + this.setParameter(WeatherAlert.KEY_EXPIRES, expires); + return this; + } + + /** + * @return {DateTime} + */ + getExpires () { + return this.getObject(DateTime, WeatherAlert.KEY_EXPIRES); + } + + /** + * @param {String[]} regions + * @return {WeatherAlert} + */ + setRegions (regions) { + this.setParameter(WeatherAlert.KEY_REGIONS, regions); + return this; + } + + /** + * @return {String[]} + */ + getRegions () { + return this.getParameter(WeatherAlert.KEY_REGIONS); + } + + /** + * @param {String} severity + * @return {WeatherAlert} + */ + setSeverity (severity) { + this.setParameter(WeatherAlert.KEY_SEVERITY, severity); + return this; + } + + /** + * @return {String} + */ + getSeverity () { + return this.getParameter(WeatherAlert.KEY_SEVERITY); + } + + /** + * @param {DateTime} issued + * @return {WeatherAlert} + */ + setTimeIssued (issued) { + this.validateType(DateTime, issued); + this.setParameter(WeatherAlert.KEY_TIME_ISSUED, issued); + return this; + } + + /** + * @return {DateTime} + */ + getTimeIssued () { + return this.getObject(DateTime, WeatherAlert.KEY_TIME_ISSUED); + } +} + +WeatherAlert.KEY_TITLE = 'title'; +WeatherAlert.KEY_SUMMARY = 'summary'; +WeatherAlert.KEY_EXPIRES = 'expires'; +WeatherAlert.KEY_REGIONS = 'regions'; +WeatherAlert.KEY_SEVERITY = 'severity'; +WeatherAlert.KEY_TIME_ISSUED = 'timeIssued'; + +export { WeatherAlert }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/WeatherData.js b/lib/js/src/rpc/structs/WeatherData.js new file mode 100644 index 00000000..a85161bc --- /dev/null +++ b/lib/js/src/rpc/structs/WeatherData.js @@ -0,0 +1,431 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { Temperature } from './Temperature.js'; +import { Image } from './Image.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { DateTime } from './DateTime.js'; + +class WeatherData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Temperature} temperature + * @return {WeatherData} + */ + setCurrentTemperature (temperature) { + this.validateType(Temperature, temperature); + this.setParameter(WeatherData.KEY_CURRENT_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Temperature} + */ + getCurrentTemperature () { + return this.getObject(Temperature, WeatherData.KEY_CURRENT_TEMPERATURE); + } + + /** + * @param {Temperature} high + * @return {WeatherData} + */ + setTemperatureHigh (high) { + this.validateType(Temperature, high); + this.setParameter(WeatherData.KEY_TEMPERATURE_HIGH, high); + return this; + } + + /** + * @return {Temperature} + */ + getTemperatureHigh () { + return this.getObject(Temperature, WeatherData.KEY_TEMPERATURE_HIGH); + } + + /** + * @param {Temperature} low + * @return {WeatherData} + */ + setTemperatureLow (low) { + this.validateType(Temperature, low); + this.setParameter(WeatherData.KEY_TEMPERATURE_LOW, low); + return this; + } + + /** + * @return {Temperature} + */ + getTemperatureLow () { + return this.getObject(Temperature, WeatherData.KEY_TEMPERATURE_LOW); + } + + /** + * @param {Temperature} temperature + * @return {WeatherData} + */ + setApparentTemperature (temperature) { + this.validateType(Temperature, temperature); + this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE, temperature); + return this; + } + + /** + * @return {Temperature} + */ + getApparentTemperature () { + return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE); + } + + /** + * @param {Temperature} high + * @return {WeatherData} + */ + setApparentTemperatureHigh (high) { + this.validateType(Temperature, high); + this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE_HIGH, high); + return this; + } + + /** + * @return {Temperature} + */ + getApparentTemperatureHigh () { + return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE_HIGH); + } + + /** + * @param {Temperature} low + * @return {WeatherData} + */ + setApparentTemperatureLow (low) { + this.validateType(Temperature, low); + this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE_LOW, low); + return this; + } + + /** + * @return {Temperature} + */ + getApparentTemperatureLow () { + return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE_LOW); + } + + /** + * @param {String} summary + * @return {WeatherData} + */ + setWeatherSummary (summary) { + this.setParameter(WeatherData.KEY_WEATHER_SUMMARY, summary); + return this; + } + + /** + * @return {String} + */ + getWeatherSummary () { + return this.getParameter(WeatherData.KEY_WEATHER_SUMMARY); + } + + /** + * @param {DateTime} time + * @return {WeatherData} + */ + setTime (time) { + this.validateType(DateTime, time); + this.setParameter(WeatherData.KEY_TIME, time); + return this; + } + + /** + * @return {DateTime} + */ + getTime () { + return this.getObject(DateTime, WeatherData.KEY_TIME); + } + + /** + * @param {Number} humidity - 0 to 1, percentage humidity + * @return {WeatherData} + */ + setHumidity (humidity) { + this.setParameter(WeatherData.KEY_HUMIDITY, humidity); + return this; + } + + /** + * @return {Number} + */ + getHumidity () { + return this.getParameter(WeatherData.KEY_HUMIDITY); + } + + /** + * @param {Number} cover - 0 to 1, percentage cloud cover + * @return {WeatherData} + */ + setCloudCover (cover) { + this.setParameter(WeatherData.KEY_CLOUD_COVER, cover); + return this; + } + + /** + * @return {Number} + */ + getCloudCover () { + return this.getParameter(WeatherData.KEY_CLOUD_COVER); + } + + /** + * @param {Number} phase - 0 to 1, percentage of the moon seen, e.g. 0 = no moon, 0.25 = quarter moon + * @return {WeatherData} + */ + setMoonPhase (phase) { + this.setParameter(WeatherData.KEY_MOON_PHASE, phase); + return this; + } + + /** + * @return {Number} + */ + getMoonPhase () { + return this.getParameter(WeatherData.KEY_MOON_PHASE); + } + + /** + * @param {Number} bearing - In degrees, true north at 0 degrees + * @return {WeatherData} + */ + setWindBearing (bearing) { + this.setParameter(WeatherData.KEY_WIND_BEARING, bearing); + return this; + } + + /** + * @return {Number} + */ + getWindBearing () { + return this.getParameter(WeatherData.KEY_WIND_BEARING); + } + + /** + * @param {Number} gust - km/hr + * @return {WeatherData} + */ + setWindGust (gust) { + this.setParameter(WeatherData.KEY_WIND_GUST, gust); + return this; + } + + /** + * @return {Number} + */ + getWindGust () { + return this.getParameter(WeatherData.KEY_WIND_GUST); + } + + /** + * @param {Number} speed - km/hr + * @return {WeatherData} + */ + setWindSpeed (speed) { + this.setParameter(WeatherData.KEY_WIND_SPEED, speed); + return this; + } + + /** + * @return {Number} + */ + getWindSpeed () { + return this.getParameter(WeatherData.KEY_WIND_SPEED); + } + + /** + * @param {Number} bearing - In degrees, true north at 0 degrees + * @return {WeatherData} + */ + setNearestStormBearing (bearing) { + this.setParameter(WeatherData.KEY_NEAREST_STORM_BEARING, bearing); + return this; + } + + /** + * @return {Number} + */ + getNearestStormBearing () { + return this.getParameter(WeatherData.KEY_NEAREST_STORM_BEARING); + } + + /** + * @param {Number} distance - In km + * @return {WeatherData} + */ + setNearestStormDistance (distance) { + this.setParameter(WeatherData.KEY_NEAREST_STORM_DISTANCE, distance); + return this; + } + + /** + * @return {Number} + */ + getNearestStormDistance () { + return this.getParameter(WeatherData.KEY_NEAREST_STORM_DISTANCE); + } + + /** + * @param {Number} accumulation - cm + * @return {WeatherData} + */ + setPrecipAccumulation (accumulation) { + this.setParameter(WeatherData.KEY_PRECIP_ACCUMULATION, accumulation); + return this; + } + + /** + * @return {Number} + */ + getPrecipAccumulation () { + return this.getParameter(WeatherData.KEY_PRECIP_ACCUMULATION); + } + + /** + * @param {Number} intensity - cm of water per hour + * @return {WeatherData} + */ + setPrecipIntensity (intensity) { + this.setParameter(WeatherData.KEY_PRECIP_INTENSITY, intensity); + return this; + } + + /** + * @return {Number} + */ + getPrecipIntensity () { + return this.getParameter(WeatherData.KEY_PRECIP_INTENSITY); + } + + /** + * @param {Number} probability - 0 to 1, percentage chance + * @return {WeatherData} + */ + setPrecipProbability (probability) { + this.setParameter(WeatherData.KEY_PRECIP_PROBABILITY, probability); + return this; + } + + /** + * @return {Number} + */ + getPrecipProbability () { + return this.getParameter(WeatherData.KEY_PRECIP_PROBABILITY); + } + + /** + * @param {String} type - e.g. "rain", "snow", "sleet", "hail" + * @return {WeatherData} + */ + setPrecipType (type) { + this.setParameter(WeatherData.KEY_PRECIP_TYPE, type); + return this; + } + + /** + * @return {String} + */ + getPrecipType () { + return this.getParameter(WeatherData.KEY_PRECIP_TYPE); + } + + /** + * @param {Number} visibility - In km + * @return {WeatherData} + */ + setVisibility (visibility) { + this.setParameter(WeatherData.KEY_VISIBILITY, visibility); + return this; + } + + /** + * @return {Number} + */ + getVisibility () { + return this.getParameter(WeatherData.KEY_VISIBILITY); + } + + /** + * @param {Image} icon + * @return {WeatherData} + */ + setWeatherIcon (icon) { + this.validateType(Image, icon); + this.setParameter(WeatherData.KEY_WEATHER_ICON, icon); + return this; + } + + /** + * @return {Image} + */ + getWeatherIcon () { + return this.getObject(Image, WeatherData.KEY_WEATHER_ICON); + } +} + +WeatherData.KEY_CURRENT_TEMPERATURE = 'currentTemperature'; +WeatherData.KEY_TEMPERATURE_HIGH = 'temperatureHigh'; +WeatherData.KEY_TEMPERATURE_LOW = 'temperatureLow'; +WeatherData.KEY_APPARENT_TEMPERATURE = 'apparentTemperature'; +WeatherData.KEY_APPARENT_TEMPERATURE_HIGH = 'apparentTemperatureHigh'; +WeatherData.KEY_APPARENT_TEMPERATURE_LOW = 'apparentTemperatureLow'; +WeatherData.KEY_WEATHER_SUMMARY = 'weatherSummary'; +WeatherData.KEY_TIME = 'time'; +WeatherData.KEY_HUMIDITY = 'humidity'; +WeatherData.KEY_CLOUD_COVER = 'cloudCover'; +WeatherData.KEY_MOON_PHASE = 'moonPhase'; +WeatherData.KEY_WIND_BEARING = 'windBearing'; +WeatherData.KEY_WIND_GUST = 'windGust'; +WeatherData.KEY_WIND_SPEED = 'windSpeed'; +WeatherData.KEY_NEAREST_STORM_BEARING = 'nearestStormBearing'; +WeatherData.KEY_NEAREST_STORM_DISTANCE = 'nearestStormDistance'; +WeatherData.KEY_PRECIP_ACCUMULATION = 'precipAccumulation'; +WeatherData.KEY_PRECIP_INTENSITY = 'precipIntensity'; +WeatherData.KEY_PRECIP_PROBABILITY = 'precipProbability'; +WeatherData.KEY_PRECIP_TYPE = 'precipType'; +WeatherData.KEY_VISIBILITY = 'visibility'; +WeatherData.KEY_WEATHER_ICON = 'weatherIcon'; + +export { WeatherData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/WeatherServiceData.js b/lib/js/src/rpc/structs/WeatherServiceData.js new file mode 100644 index 00000000..2c93b8d5 --- /dev/null +++ b/lib/js/src/rpc/structs/WeatherServiceData.js @@ -0,0 +1,160 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { WeatherData } from './WeatherData.js'; +import { LocationDetails } from './LocationDetails.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { WeatherAlert } from './WeatherAlert.js'; + +/** + * This data is related to what a weather service would provide + */ +class WeatherServiceData extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {LocationDetails} location + * @return {WeatherServiceData} + */ + setLocation (location) { + this.validateType(LocationDetails, location); + this.setParameter(WeatherServiceData.KEY_LOCATION, location); + return this; + } + + /** + * @return {LocationDetails} + */ + getLocation () { + return this.getObject(LocationDetails, WeatherServiceData.KEY_LOCATION); + } + + /** + * @param {WeatherData} forecast + * @return {WeatherServiceData} + */ + setCurrentForecast (forecast) { + this.validateType(WeatherData, forecast); + this.setParameter(WeatherServiceData.KEY_CURRENT_FORECAST, forecast); + return this; + } + + /** + * @return {WeatherData} + */ + getCurrentForecast () { + return this.getObject(WeatherData, WeatherServiceData.KEY_CURRENT_FORECAST); + } + + /** + * @param {WeatherData[]} forecast + * @return {WeatherServiceData} + */ + setMinuteForecast (forecast) { + this.validateType(WeatherData, forecast, true); + this.setParameter(WeatherServiceData.KEY_MINUTE_FORECAST, forecast); + return this; + } + + /** + * @return {WeatherData[]} + */ + getMinuteForecast () { + return this.getObject(WeatherData, WeatherServiceData.KEY_MINUTE_FORECAST); + } + + /** + * @param {WeatherData[]} forecast + * @return {WeatherServiceData} + */ + setHourlyForecast (forecast) { + this.validateType(WeatherData, forecast, true); + this.setParameter(WeatherServiceData.KEY_HOURLY_FORECAST, forecast); + return this; + } + + /** + * @return {WeatherData[]} + */ + getHourlyForecast () { + return this.getObject(WeatherData, WeatherServiceData.KEY_HOURLY_FORECAST); + } + + /** + * @param {WeatherData[]} forecast + * @return {WeatherServiceData} + */ + setMultidayForecast (forecast) { + this.validateType(WeatherData, forecast, true); + this.setParameter(WeatherServiceData.KEY_MULTIDAY_FORECAST, forecast); + return this; + } + + /** + * @return {WeatherData[]} + */ + getMultidayForecast () { + return this.getObject(WeatherData, WeatherServiceData.KEY_MULTIDAY_FORECAST); + } + + /** + * @param {WeatherAlert[]} alerts - This array should be ordered with the first object being the current day + * @return {WeatherServiceData} + */ + setAlerts (alerts) { + this.validateType(WeatherAlert, alerts, true); + this.setParameter(WeatherServiceData.KEY_ALERTS, alerts); + return this; + } + + /** + * @return {WeatherAlert[]} + */ + getAlerts () { + return this.getObject(WeatherAlert, WeatherServiceData.KEY_ALERTS); + } +} + +WeatherServiceData.KEY_LOCATION = 'location'; +WeatherServiceData.KEY_CURRENT_FORECAST = 'currentForecast'; +WeatherServiceData.KEY_MINUTE_FORECAST = 'minuteForecast'; +WeatherServiceData.KEY_HOURLY_FORECAST = 'hourlyForecast'; +WeatherServiceData.KEY_MULTIDAY_FORECAST = 'multidayForecast'; +WeatherServiceData.KEY_ALERTS = 'alerts'; + +export { WeatherServiceData }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/WeatherServiceManifest.js b/lib/js/src/rpc/structs/WeatherServiceManifest.js new file mode 100644 index 00000000..b3cbc6a3 --- /dev/null +++ b/lib/js/src/rpc/structs/WeatherServiceManifest.js @@ -0,0 +1,131 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { RpcStruct } from '../RpcStruct.js'; + +class WeatherServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Boolean} supported + * @return {WeatherServiceManifest} + */ + setCurrentForecastSupported (supported) { + this.setParameter(WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED, supported); + return this; + } + + /** + * @return {Boolean} + */ + getCurrentForecastSupported () { + return this.getParameter(WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED); + } + + /** + * @param {Number} amount + * @return {WeatherServiceManifest} + */ + setMaxMultidayForecastAmount (amount) { + this.setParameter(WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT, amount); + return this; + } + + /** + * @return {Number} + */ + getMaxMultidayForecastAmount () { + return this.getParameter(WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT); + } + + /** + * @param {Number} amount + * @return {WeatherServiceManifest} + */ + setMaxHourlyForecastAmount (amount) { + this.setParameter(WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT, amount); + return this; + } + + /** + * @return {Number} + */ + getMaxHourlyForecastAmount () { + return this.getParameter(WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT); + } + + /** + * @param {Number} amount + * @return {WeatherServiceManifest} + */ + setMaxMinutelyForecastAmount (amount) { + this.setParameter(WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT, amount); + return this; + } + + /** + * @return {Number} + */ + getMaxMinutelyForecastAmount () { + return this.getParameter(WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT); + } + + /** + * @param {Boolean} supported + * @return {WeatherServiceManifest} + */ + setWeatherForLocationSupported (supported) { + this.setParameter(WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED, supported); + return this; + } + + /** + * @return {Boolean} + */ + getWeatherForLocationSupported () { + return this.getParameter(WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED); + } +} + +WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED = 'currentForecastSupported'; +WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT = 'maxMultidayForecastAmount'; +WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT = 'maxHourlyForecastAmount'; +WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT = 'maxMinutelyForecastAmount'; +WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED = 'weatherForLocationSupported'; + +export { WeatherServiceManifest }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/WindowCapability.js b/lib/js/src/rpc/structs/WindowCapability.js new file mode 100644 index 00000000..2e78c30b --- /dev/null +++ b/lib/js/src/rpc/structs/WindowCapability.js @@ -0,0 +1,215 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { ImageField } from './ImageField.js'; +import { TextField } from './TextField.js'; +import { ImageType } from '../enums/ImageType.js'; +import { MenuLayout } from '../enums/MenuLayout.js'; +import { RpcStruct } from '../RpcStruct.js'; +import { ButtonCapabilities } from './ButtonCapabilities.js'; +import { SoftButtonCapabilities } from './SoftButtonCapabilities.js'; + +class WindowCapability extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {Number} id - The specified ID of the window. This ID is either one used when sending the CreateWindow + * request, or one of the predefined window ID values from the enum PredefinedWindows. If + * ommited, value is assumed to be the main window on the main display. + * @return {WindowCapability} + */ + setWindowID (id) { + this.setParameter(WindowCapability.KEY_WINDOW_ID, id); + return this; + } + + /** + * @return {Number} + */ + getWindowID () { + return this.getParameter(WindowCapability.KEY_WINDOW_ID); + } + + /** + * @param {TextField[]} fields - A set of all fields that support text data. See TextField + * @return {WindowCapability} + */ + setTextFields (fields) { + this.validateType(TextField, fields, true); + this.setParameter(WindowCapability.KEY_TEXT_FIELDS, fields); + return this; + } + + /** + * @return {TextField[]} + */ + getTextFields () { + return this.getObject(TextField, WindowCapability.KEY_TEXT_FIELDS); + } + + /** + * @param {ImageField[]} fields - A set of all fields that support images. See ImageField + * @return {WindowCapability} + */ + setImageFields (fields) { + this.validateType(ImageField, fields, true); + this.setParameter(WindowCapability.KEY_IMAGE_FIELDS, fields); + return this; + } + + /** + * @return {ImageField[]} + */ + getImageFields () { + return this.getObject(ImageField, WindowCapability.KEY_IMAGE_FIELDS); + } + + /** + * @param {ImageType[]} supported - Provides information about image types supported by the system. + * @return {WindowCapability} + */ + setImageTypeSupported (supported) { + this.validateType(ImageType, supported, true); + this.setParameter(WindowCapability.KEY_IMAGE_TYPE_SUPPORTED, supported); + return this; + } + + /** + * @return {ImageType[]} + */ + getImageTypeSupported () { + return this.getObject(ImageType, WindowCapability.KEY_IMAGE_TYPE_SUPPORTED); + } + + /** + * @param {String[]} available - A set of all window templates available on the head unit. + * @return {WindowCapability} + */ + setTemplatesAvailable (available) { + this.setParameter(WindowCapability.KEY_TEMPLATES_AVAILABLE, available); + return this; + } + + /** + * @return {String[]} + */ + getTemplatesAvailable () { + return this.getParameter(WindowCapability.KEY_TEMPLATES_AVAILABLE); + } + + /** + * @param {Number} available - The number of on-window custom presets available (if any); otherwise omitted. + * @return {WindowCapability} + */ + setNumCustomPresetsAvailable (available) { + this.setParameter(WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, available); + return this; + } + + /** + * @return {Number} + */ + getNumCustomPresetsAvailable () { + return this.getParameter(WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE); + } + + /** + * @param {ButtonCapabilities[]} capabilities - The number of buttons and the capabilities of each on-window button. + * @return {WindowCapability} + */ + setButtonCapabilities (capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(WindowCapability.KEY_BUTTON_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {ButtonCapabilities[]} + */ + getButtonCapabilities () { + return this.getObject(ButtonCapabilities, WindowCapability.KEY_BUTTON_CAPABILITIES); + } + + /** + * @param {SoftButtonCapabilities[]} capabilities - The number of soft buttons available on-window and the + * capabilities for each button. + * @return {WindowCapability} + */ + setSoftButtonCapabilities (capabilities) { + this.validateType(SoftButtonCapabilities, capabilities, true); + this.setParameter(WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES, capabilities); + return this; + } + + /** + * @return {SoftButtonCapabilities[]} + */ + getSoftButtonCapabilities () { + return this.getObject(SoftButtonCapabilities, WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES); + } + + /** + * @param {MenuLayout[]} available - An array of available menu layouts. If this parameter is not provided, only the + * `LIST` layout is assumed to be available + * @return {WindowCapability} + */ + setMenuLayoutsAvailable (available) { + this.validateType(MenuLayout, available, true); + this.setParameter(WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE, available); + return this; + } + + /** + * @return {MenuLayout[]} + */ + getMenuLayoutsAvailable () { + return this.getObject(MenuLayout, WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE); + } +} + +WindowCapability.KEY_WINDOW_ID = 'windowID'; +WindowCapability.KEY_TEXT_FIELDS = 'textFields'; +WindowCapability.KEY_IMAGE_FIELDS = 'imageFields'; +WindowCapability.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported'; +WindowCapability.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable'; +WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable'; +WindowCapability.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; +WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities'; +WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE = 'menuLayoutsAvailable'; + +export { WindowCapability }; \ No newline at end of file diff --git a/lib/js/src/rpc/structs/WindowTypeCapabilities.js b/lib/js/src/rpc/structs/WindowTypeCapabilities.js new file mode 100644 index 00000000..7b72a675 --- /dev/null +++ b/lib/js/src/rpc/structs/WindowTypeCapabilities.js @@ -0,0 +1,82 @@ +/* eslint-disable camelcase */ +/* +* Copyright (c) 2020, SmartDeviceLink Consortium, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* Redistributions of source code must retain the above copyright notice, this +* list of conditions and the following disclaimer. +* +* Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the +* distribution. +* +* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of +* its contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +import { WindowType } from '../enums/WindowType.js'; +import { RpcStruct } from '../RpcStruct.js'; + +class WindowTypeCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor (parameters) { + super(parameters); + } + + /** + * @param {WindowType} type + * @return {WindowTypeCapabilities} + */ + setType (type) { + this.validateType(WindowType, type); + this.setParameter(WindowTypeCapabilities.KEY_TYPE, type); + return this; + } + + /** + * @return {WindowType} + */ + getType () { + return this.getObject(WindowType, WindowTypeCapabilities.KEY_TYPE); + } + + /** + * @param {Number} windows + * @return {WindowTypeCapabilities} + */ + setMaximumNumberOfWindows (windows) { + this.setParameter(WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS, windows); + return this; + } + + /** + * @return {Number} + */ + getMaximumNumberOfWindows () { + return this.getParameter(WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS); + } +} + +WindowTypeCapabilities.KEY_TYPE = 'type'; +WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS = 'maximumNumberOfWindows'; + +export { WindowTypeCapabilities }; \ No newline at end of file diff --git a/lib/node/dist/index.js b/lib/node/dist/index.js index dab264e6..c8b33483 100644 --- a/lib/node/dist/index.js +++ b/lib/node/dist/index.js @@ -726,38 +726,251 @@ } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Contains detailed information about the registered application. + */ + + class AppInfo extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - The name displayed for the mobile application on the mobile device (can differ from the + * app name set in the initial RAI request). + * @return {AppInfo} + */ + + + setAppDisplayName(name) { + this.setParameter(AppInfo.KEY_APP_DISPLAY_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getAppDisplayName() { + return this.getParameter(AppInfo.KEY_APP_DISPLAY_NAME); + } + /** + * @param {String} id - The AppBundleID of an iOS application or package name of the Android application. This + * supports App Launch strategies for each platform. + * @return {AppInfo} + */ + + + setAppBundleID(id) { + this.setParameter(AppInfo.KEY_APP_BUNDLE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getAppBundleID() { + return this.getParameter(AppInfo.KEY_APP_BUNDLE_ID); + } + /** + * @param {String} version - Represents the build version number of this particular mobile app. + * @return {AppInfo} + */ + + + setAppVersion(version) { + this.setParameter(AppInfo.KEY_APP_VERSION, version); + return this; + } + /** + * @return {String} + */ + + + getAppVersion() { + return this.getParameter(AppInfo.KEY_APP_VERSION); + } + /** + * @param {String} icon - A file reference to the icon utilized by this app (simplifies the process of setting an + * app icon during app registration). + * @return {AppInfo} + */ + + + setAppIcon(icon) { + this.setParameter(AppInfo.KEY_APP_ICON, icon); + return this; + } + /** + * @return {String} + */ + + + getAppIcon() { + return this.getParameter(AppInfo.KEY_APP_ICON); + } + + } + + AppInfo.KEY_APP_DISPLAY_NAME = 'appDisplayName'; + AppInfo.KEY_APP_BUNDLE_ID = 'appBundleID'; + AppInfo.KEY_APP_VERSION = 'appVersion'; + AppInfo.KEY_APP_ICON = 'appIcon'; + + /* eslint-disable camelcase */ + + class RGBColor extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} red + * @return {RGBColor} + */ + + + setRed(red) { + this.setParameter(RGBColor.KEY_RED, red); + return this; + } + /** + * @return {Number} + */ + + + getRed() { + return this.getParameter(RGBColor.KEY_RED); + } + /** + * @param {Number} green + * @return {RGBColor} + */ + + + setGreen(green) { + this.setParameter(RGBColor.KEY_GREEN, green); + return this; + } + /** + * @return {Number} + */ + + + getGreen() { + return this.getParameter(RGBColor.KEY_GREEN); + } + /** + * @param {Number} blue + * @return {RGBColor} + */ + + + setBlue(blue) { + this.setParameter(RGBColor.KEY_BLUE, blue); + return this; + } + /** + * @return {Number} + */ + + + getBlue() { + return this.getParameter(RGBColor.KEY_BLUE); + } + + } + + RGBColor.KEY_RED = 'red'; + RGBColor.KEY_GREEN = 'green'; + RGBColor.KEY_BLUE = 'blue'; + + /* eslint-disable camelcase */ + /** + * A color scheme for all display layout templates. + */ + + class TemplateColorScheme extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {RGBColor} color - The primary "accent" color + * @return {TemplateColorScheme} + */ + + + setPrimaryColor(color) { + this.validateType(RGBColor, color); + this.setParameter(TemplateColorScheme.KEY_PRIMARY_COLOR, color); + return this; + } + /** + * @return {RGBColor} + */ + + + getPrimaryColor() { + return this.getObject(RGBColor, TemplateColorScheme.KEY_PRIMARY_COLOR); + } + /** + * @param {RGBColor} color - The secondary "accent" color + * @return {TemplateColorScheme} + */ + + + setSecondaryColor(color) { + this.validateType(RGBColor, color); + this.setParameter(TemplateColorScheme.KEY_SECONDARY_COLOR, color); + return this; + } + /** + * @return {RGBColor} + */ + + + getSecondaryColor() { + return this.getObject(RGBColor, TemplateColorScheme.KEY_SECONDARY_COLOR); + } + /** + * @param {RGBColor} color - The color of the background + * @return {TemplateColorScheme} + */ + + + setBackgroundColor(color) { + this.validateType(RGBColor, color); + this.setParameter(TemplateColorScheme.KEY_BACKGROUND_COLOR, color); + return this; + } + /** + * @return {RGBColor} + */ + + + getBackgroundColor() { + return this.getObject(RGBColor, TemplateColorScheme.KEY_BACKGROUND_COLOR); + } + + } + + TemplateColorScheme.KEY_PRIMARY_COLOR = 'primaryColor'; + TemplateColorScheme.KEY_SECONDARY_COLOR = 'secondaryColor'; + TemplateColorScheme.KEY_BACKGROUND_COLOR = 'backgroundColor'; + + /* eslint-disable camelcase */ /** + * Enumeration linking function names with function IDs in SmartDeviceLink protocol. Assumes enumeration starts at + * value 0. * @typedef {Enum} FunctionID * @property {Object} _MAP */ @@ -770,676 +983,716 @@ super(); } /** - * @return {Number} - */ + * @return {Number} + */ + + + static get RESERVED() { + return FunctionID._MAP.RESERVED; + } + /** + * @return {Number} + */ static get RegisterAppInterface() { return FunctionID._MAP.RegisterAppInterface; } /** - * @return {Number} - */ + * @return {Number} + */ static get UnregisterAppInterface() { return FunctionID._MAP.UnregisterAppInterface; } /** - * @return {Number} - */ + * @return {Number} + */ static get SetGlobalProperties() { return FunctionID._MAP.SetGlobalProperties; } /** - * @return {Number} - */ + * @return {Number} + */ static get ResetGlobalProperties() { return FunctionID._MAP.ResetGlobalProperties; } /** - * @return {Number} - */ + * @return {Number} + */ static get AddCommand() { return FunctionID._MAP.AddCommand; } /** - * @return {Number} - */ + * @return {Number} + */ static get DeleteCommand() { return FunctionID._MAP.DeleteCommand; } /** - * @return {Number} - */ + * @return {Number} + */ static get AddSubMenu() { return FunctionID._MAP.AddSubMenu; } /** - * @return {Number} - */ + * @return {Number} + */ static get DeleteSubMenu() { return FunctionID._MAP.DeleteSubMenu; } /** - * @return {Number} - */ + * @return {Number} + */ static get CreateInteractionChoiceSet() { return FunctionID._MAP.CreateInteractionChoiceSet; } /** - * @return {Number} - */ + * @return {Number} + */ static get PerformInteraction() { return FunctionID._MAP.PerformInteraction; } /** - * @return {Number} - */ + * @return {Number} + */ static get DeleteInteractionChoiceSet() { return FunctionID._MAP.DeleteInteractionChoiceSet; } /** - * @return {Number} - */ + * @return {Number} + */ static get Alert() { return FunctionID._MAP.Alert; } /** - * @return {Number} - */ + * @return {Number} + */ static get Show() { return FunctionID._MAP.Show; } /** - * @return {Number} - */ + * @return {Number} + */ static get Speak() { return FunctionID._MAP.Speak; } /** - * @return {Number} - */ + * @return {Number} + */ static get SetMediaClockTimer() { return FunctionID._MAP.SetMediaClockTimer; } /** - * @return {Number} - */ + * @return {Number} + */ static get PerformAudioPassThru() { return FunctionID._MAP.PerformAudioPassThru; } /** - * @return {Number} - */ + * @return {Number} + */ static get EndAudioPassThru() { return FunctionID._MAP.EndAudioPassThru; } /** - * @return {Number} - */ + * @return {Number} + */ static get SubscribeButton() { return FunctionID._MAP.SubscribeButton; } /** - * @return {Number} - */ + * @return {Number} + */ static get UnsubscribeButton() { return FunctionID._MAP.UnsubscribeButton; } /** - * @return {Number} - */ + * @return {Number} + */ static get SubscribeVehicleData() { return FunctionID._MAP.SubscribeVehicleData; } /** - * @return {Number} - */ + * @return {Number} + */ static get UnsubscribeVehicleData() { return FunctionID._MAP.UnsubscribeVehicleData; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetVehicleData() { return FunctionID._MAP.GetVehicleData; } /** - * @return {Number} - */ + * @return {Number} + */ static get ReadDID() { return FunctionID._MAP.ReadDID; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetDTCs() { return FunctionID._MAP.GetDTCs; } /** - * @return {Number} - */ + * @return {Number} + */ static get ScrollableMessage() { return FunctionID._MAP.ScrollableMessage; } /** - * @return {Number} - */ + * @return {Number} + */ static get Slider() { return FunctionID._MAP.Slider; } /** - * @return {Number} - */ + * @return {Number} + */ static get ShowConstantTBT() { return FunctionID._MAP.ShowConstantTBT; } /** - * @return {Number} - */ + * @return {Number} + */ static get AlertManeuver() { return FunctionID._MAP.AlertManeuver; } /** - * @return {Number} - */ + * @return {Number} + */ static get UpdateTurnList() { return FunctionID._MAP.UpdateTurnList; } /** - * @return {Number} - */ + * @return {Number} + */ static get ChangeRegistration() { return FunctionID._MAP.ChangeRegistration; } /** - * @return {Number} - */ + * @return {Number} + */ static get GenericResponse() { return FunctionID._MAP.GenericResponse; } /** - * @return {Number} - */ + * @return {Number} + */ static get PutFile() { return FunctionID._MAP.PutFile; } /** - * @return {Number} - */ + * @return {Number} + */ static get DeleteFile() { return FunctionID._MAP.DeleteFile; } /** - * @return {Number} - */ + * @return {Number} + */ static get ListFiles() { return FunctionID._MAP.ListFiles; } /** - * @return {Number} - */ + * @return {Number} + */ static get SetAppIcon() { return FunctionID._MAP.SetAppIcon; } /** - * @return {Number} - */ + * @return {Number} + */ static get SetDisplayLayout() { return FunctionID._MAP.SetDisplayLayout; } /** - * @return {Number} - */ + * @return {Number} + */ static get DiagnosticMessage() { return FunctionID._MAP.DiagnosticMessage; } /** - * @return {Number} - */ + * @return {Number} + */ static get SystemRequest() { return FunctionID._MAP.SystemRequest; } /** - * @return {Number} - */ + * @return {Number} + */ static get SendLocation() { return FunctionID._MAP.SendLocation; } /** - * @return {Number} - */ + * @return {Number} + */ static get DialNumber() { return FunctionID._MAP.DialNumber; } /** - * @return {Number} - */ + * @return {Number} + */ static get ButtonPress() { return FunctionID._MAP.ButtonPress; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetInteriorVehicleData() { return FunctionID._MAP.GetInteriorVehicleData; } /** - * @return {Number} - */ + * @return {Number} + */ static get SetInteriorVehicleData() { return FunctionID._MAP.SetInteriorVehicleData; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetWayPoints() { return FunctionID._MAP.GetWayPoints; } /** - * @return {Number} - */ + * @return {Number} + */ static get SubscribeWayPoints() { return FunctionID._MAP.SubscribeWayPoints; } /** - * @return {Number} - */ + * @return {Number} + */ static get UnsubscribeWayPoints() { return FunctionID._MAP.UnsubscribeWayPoints; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetSystemCapability() { return FunctionID._MAP.GetSystemCapability; } /** - * @return {Number} - */ + * @return {Number} + */ static get SendHapticData() { return FunctionID._MAP.SendHapticData; } /** - * @return {Number} - */ + * @return {Number} + */ static get SetCloudAppProperties() { return FunctionID._MAP.SetCloudAppProperties; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetCloudAppProperties() { return FunctionID._MAP.GetCloudAppProperties; } /** - * @return {Number} - */ + * @return {Number} + */ static get PublishAppService() { return FunctionID._MAP.PublishAppService; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetAppServiceData() { return FunctionID._MAP.GetAppServiceData; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetFile() { return FunctionID._MAP.GetFile; } /** - * @return {Number} - */ + * @return {Number} + */ static get PerformAppServiceInteraction() { return FunctionID._MAP.PerformAppServiceInteraction; } /** - * @return {Number} - */ + * @return {Number} + */ static get UnpublishAppService() { return FunctionID._MAP.UnpublishAppService; } /** - * @return {Number} - */ + * @return {Number} + */ static get CancelInteraction() { return FunctionID._MAP.CancelInteraction; } /** - * @return {Number} - */ + * @return {Number} + */ static get CloseApplication() { return FunctionID._MAP.CloseApplication; } /** - * @return {Number} - */ + * @return {Number} + */ static get ShowAppMenu() { return FunctionID._MAP.ShowAppMenu; } /** - * @return {Number} - */ + * @return {Number} + */ static get CreateWindow() { return FunctionID._MAP.CreateWindow; } /** - * @return {Number} - */ + * @return {Number} + */ static get DeleteWindow() { return FunctionID._MAP.DeleteWindow; } /** - * @return {Number} - */ + * @return {Number} + */ static get GetInteriorVehicleDataConsent() { return FunctionID._MAP.GetInteriorVehicleDataConsent; } /** - * @return {Number} - */ + * @return {Number} + */ static get ReleaseInteriorVehicleDataModule() { return FunctionID._MAP.ReleaseInteriorVehicleDataModule; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnHMIStatus() { return FunctionID._MAP.OnHMIStatus; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnAppInterfaceUnregistered() { return FunctionID._MAP.OnAppInterfaceUnregistered; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnButtonEvent() { return FunctionID._MAP.OnButtonEvent; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnButtonPress() { return FunctionID._MAP.OnButtonPress; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnVehicleData() { return FunctionID._MAP.OnVehicleData; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnCommand() { return FunctionID._MAP.OnCommand; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnTBTClientState() { return FunctionID._MAP.OnTBTClientState; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnDriverDistraction() { return FunctionID._MAP.OnDriverDistraction; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnPermissionsChange() { return FunctionID._MAP.OnPermissionsChange; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnAudioPassThru() { return FunctionID._MAP.OnAudioPassThru; } /** - * @return {Number} - */ - + * @return {Number} + */ + static get OnLanguageChange() { return FunctionID._MAP.OnLanguageChange; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnKeyboardInput() { return FunctionID._MAP.OnKeyboardInput; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnTouchEvent() { return FunctionID._MAP.OnTouchEvent; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnSystemRequest() { return FunctionID._MAP.OnSystemRequest; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnHashChange() { return FunctionID._MAP.OnHashChange; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnInteriorVehicleData() { return FunctionID._MAP.OnInteriorVehicleData; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnWayPointChange() { return FunctionID._MAP.OnWayPointChange; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnRCStatus() { return FunctionID._MAP.OnRCStatus; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnAppServiceData() { return FunctionID._MAP.OnAppServiceData; } /** - * @return {Number} - */ + * @return {Number} + */ static get OnSystemCapabilityUpdated() { return FunctionID._MAP.OnSystemCapabilityUpdated; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @return {Number} + */ + + + static get EncodedSyncPData() { + return FunctionID._MAP.EncodedSyncPData; + } + /** + * @return {Number} + */ + + + static get SdlPData() { + return FunctionID._MAP.SdlPData; + } + /** + * @return {Number} + */ + + + static get OnEncodedSyncPData() { + return FunctionID._MAP.OnEncodedSyncPData; + } + /** + * @return {Number} + */ + + + static get OnSyncPData() { + return FunctionID._MAP.OnSyncPData; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { return FunctionID._valueForKey(key, FunctionID._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { @@ -1449,6 +1702,7 @@ } FunctionID._MAP = Object.freeze({ + 'RESERVED': 0, 'RegisterAppInterface': 0x01, 'UnregisterAppInterface': 0x02, 'SetGlobalProperties': 0x03, @@ -1530,417 +1784,227 @@ 'OnWayPointChange': 0x8010, 'OnRCStatus': 0x8011, 'OnAppServiceData': 0x8012, - 'OnSystemCapabilityUpdated': 0x8013 + 'OnSystemCapabilityUpdated': 0x8013, + 'EncodedSyncPData': 0x10000, + 'SyncPData': 0x10001, + 'OnEncodedSyncPData': 0x18000, + 'OnSyncPData': 0x18001 }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Object} RpcMessage - * @property {RpcType} rpcType + * Contains information about the TTS capabilities. + * @typedef {Enum} SpeechCapabilities + * @property {Object} _MAP */ - class RpcMessage extends RpcStruct { - /* - { - "rpcType": "Request", - "functionName": "RegisterAppInterface", - "coorelationID": "320948", - "isEncrypted": false, - "parameters": { - "appName": "Hello" - }, - "bulkData": "...", - } - */ - - /** - * @constructor - */ - constructor(store = {}) { - super(store.parameters); - this._isEncrypted = false; - this._rpcType = store.rpcType; - this._functionName = store.functionName; - this._correlationID = store.correlationID; - this.setBulkData(store.bulkData); - } - /** - * @return {RpcType} - */ - - - getRPCType() { - return this._rpcType; - } + class SpeechCapabilities extends Enum { /** - * @param {RpcType} type - * @return {RpcMessage} - */ - - - setRPCType(type) { - this._rpcType = type; - return this; + * @constructor + */ + constructor() { + super(); } /** - * @return {FunctionID} type - */ + * @return {String} + */ - getFunctionName() { - return this._functionName; + static get SC_TEXT() { + return SpeechCapabilities._MAP.SC_TEXT; } /** - * @param {FunctionID} name - * @return {RpcMessage} - */ - + * @return {String} + */ - setFunctionName(name) { - if (typeof name !== 'string') { - this._functionName = FunctionID.keyForValue(name); - } else { - this._functionName = name; - } - return this; + static get SAPI_PHONEMES() { + return SpeechCapabilities._MAP.SAPI_PHONEMES; } /** - * @return {String} type - */ + * @return {String} + */ - getCorrelationId() { - return this._correlationID; + static get LHPLUS_PHONEMES() { + return SpeechCapabilities._MAP.LHPLUS_PHONEMES; } /** - * @param {String} name - * @return {RpcMessage} - */ + * @return {String} + */ - setCorrelationId(id) { - this._correlationID = id; - return this; + static get PRE_RECORDED() { + return SpeechCapabilities._MAP.PRE_RECORDED; } /** - * @return {Uint8Array} data - */ + * @return {String} + */ - getBulkData() { - return this._bulkData; + static get SILENCE() { + return SpeechCapabilities._MAP.SILENCE; } /** - * @param {UInt8Array} data - * @return {RpcMessage} - */ - + * @return {String} + */ - setBulkData(data = null) { - if (data !== null) { - this._bulkData = data.slice(0); - } else { - this._bulkData = null; - } - return this; + static get FILE() { + return SpeechCapabilities._MAP.FILE; } /** - * @return {Boolean} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - getIsEncrypted() { - return this._isEncrypted; + static valueForKey(key) { + return SpeechCapabilities._valueForKey(key, SpeechCapabilities._MAP); } /** - * @param {Boolean} bool - * @return {RpcMessage} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - setIsEncrypted(bool) { - this._isEncrypted = bool; - return this; + static keyForValue(value) { + return SpeechCapabilities._keyForValue(value, SpeechCapabilities._MAP); } } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + SpeechCapabilities._MAP = Object.freeze({ + 'SC_TEXT': 'TEXT', + 'SAPI_PHONEMES': 'SAPI_PHONEMES', + 'LHPLUS_PHONEMES': 'LHPLUS_PHONEMES', + 'PRE_RECORDED': 'PRE_RECORDED', + 'SILENCE': 'SILENCE', + 'FILE': 'FILE' + }); + + /* eslint-disable camelcase */ /** - * @typedef {Enum} RpcType - * @property {Object} _MAP + * A TTS chunk, that consists of text/phonemes to speak or the name of a file to play, and a TTS type (like text or + * SAPI) */ - class RpcType extends Enum { - /** - * @constructor - */ - constructor() { - super(); - } + class TTSChunk extends RpcStruct { /** - * @return {Number} + * @constructor */ - - - static get NOTIFICATION() { - return RpcType._MAP.NOTIFICATION; + constructor(parameters) { + super(parameters); } /** - * @return {Number} + * @param {String} text - The text or phonemes to speak, or the name of the audio file to play. May not be empty. + * @return {TTSChunk} */ - static get RESPONSE() { - return RpcType._MAP.RESPONSE; + setText(text) { + this.setParameter(TTSChunk.KEY_TEXT, text); + return this; } /** - * @return {Number} + * @return {String} */ - static get REQUEST() { - return RpcType._MAP.REQUEST; + getText() { + return this.getParameter(TTSChunk.KEY_TEXT); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @param {SpeechCapabilities} type - Describes whether the TTS chunk is plain text, a specific phoneme set, or an + * audio file. See SpeechCapabilities + * @return {TTSChunk} + */ - static valueForKey(key) { - return RpcType._valueForKey(key, RpcType._MAP); + setType(type) { + this.validateType(SpeechCapabilities, type); + this.setParameter(TTSChunk.KEY_TYPE, type); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @return {SpeechCapabilities} + */ - static keyForValue(value) { - return RpcType._keyForValue(value, RpcType._MAP); + getType() { + return this.getObject(SpeechCapabilities, TTSChunk.KEY_TYPE); } } - RpcType._MAP = Object.freeze({ - 'NOTIFICATION': 0x2, - 'RESPONSE': 0x1, - 'REQUEST': 0x0 - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - class RpcRequest extends RpcMessage { - /** - * @constructor - */ - constructor(store) { - super(store); - this.setRPCType(RpcType.REQUEST); - this._promise = null; - } - /** - * @return {Promise} - */ - - - getOnRPCResponsePromise() { - return this._promise; - } - /** - * @param {Promise} promise - * @return {RpcMessage} - */ - - - setOnRPCResponsePromise(promise) { - this.validateType(Promise, promise); - this._promise = promise; - return this; - } - - } + TTSChunk.KEY_TEXT = 'text'; + TTSChunk.KEY_TYPE = 'type'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Specifies the version number of the SmartDeviceLink protocol that is supported by the mobile application + */ class SdlMsgVersion extends RpcStruct { + /** + * @constructor + */ constructor(parameters) { super(parameters); } /** - * @param {Number} the major version of this object - * @return {SdlMsgVersion} - */ + * @param {Number} version - The major version indicates versions that is not-compatible to previous versions. + * @return {SdlMsgVersion} + */ - setMajorVersion(value) { - this.setParameter(SdlMsgVersion.KEY_MAJOR_VERSION, value); + setMajorVersion(version) { + this.setParameter(SdlMsgVersion.KEY_MAJOR_VERSION, version); return this; } /** - * @return {Number} the major version of this object - */ + * @return {Number} + */ getMajorVersion() { return this.getParameter(SdlMsgVersion.KEY_MAJOR_VERSION); } /** - * @param {Number} the minor version of this object - * @return {SdlMsgVersion} - */ + * @param {Number} version - The minor version indicates a change to a previous version that should still allow to + * be run on an older version (with limited functionality) + * @return {SdlMsgVersion} + */ - setMinorVersion(value) { - this.setParameter(SdlMsgVersion.KEY_MINOR_VERSION, value); + setMinorVersion(version) { + this.setParameter(SdlMsgVersion.KEY_MINOR_VERSION, version); return this; } /** - * @return {Number} the minor version of this object - */ + * @return {Number} + */ getMinorVersion() { return this.getParameter(SdlMsgVersion.KEY_MINOR_VERSION); } /** - * @param {Number} the patch version of this object - * @return {SdlMsgVersion} - */ + * @param {Number} version - The patch version indicates a fix to existing functionality in a previous version that + * should still be able to be run on an older version + * @return {SdlMsgVersion} + */ - setPatchVersion(value) { - this.setParameter(SdlMsgVersion.KEY_PATCH_VERSION, value); + setPatchVersion(version) { + this.setParameter(SdlMsgVersion.KEY_PATCH_VERSION, version); return this; } /** - * @return {Number} the patch version of this objects - */ + * @return {Number} + */ getPatchVersion() { @@ -1953,43 +2017,17 @@ SdlMsgVersion.KEY_MINOR_VERSION = 'minorVersion'; SdlMsgVersion.KEY_PATCH_VERSION = 'patchVersion'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} SpeechCapabilities + * Enumeration listing possible app types. + * @typedef {Enum} AppHMIType * @property {Object} _MAP */ - class SpeechCapabilities extends Enum { + class AppHMIType extends Enum { + /** + * @constructor + */ constructor() { super(); } @@ -1998,632 +2036,563 @@ */ - static get SC_TEXT() { - return SpeechCapabilities._MAP.SC_TEXT; + static get DEFAULT() { + return AppHMIType._MAP.DEFAULT; } /** * @return {String} */ - static get SAPI_PHONEMES() { - return SpeechCapabilities._MAP.SAPI_PHONEMES; + static get COMMUNICATION() { + return AppHMIType._MAP.COMMUNICATION; } /** * @return {String} */ - static get LHPLUS_PHONEMES() { - return SpeechCapabilities._MAP.LHPLUS_PHONEMES; + static get MEDIA() { + return AppHMIType._MAP.MEDIA; } /** * @return {String} */ - static get PRE_RECORDED() { - return SpeechCapabilities._MAP.PRE_RECORDED; + static get MESSAGING() { + return AppHMIType._MAP.MESSAGING; } /** * @return {String} */ - static get SILENCE() { - return SpeechCapabilities._MAP.SILENCE; + static get NAVIGATION() { + return AppHMIType._MAP.NAVIGATION; } /** * @return {String} */ - static get FILE() { - return SpeechCapabilities._MAP.FILE; + static get INFORMATION() { + return AppHMIType._MAP.INFORMATION; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ - + * @return {String} + */ - static valueForKey(key) { - return SpeechCapabilities._valueForKey(key, SpeechCapabilities._MAP); + + static get SOCIAL() { + return AppHMIType._MAP.SOCIAL; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @return {String} + */ - static keyForValue(value) { - return SpeechCapabilities._keyForValue(value, SpeechCapabilities._MAP); + static get BACKGROUND_PROCESS() { + return AppHMIType._MAP.BACKGROUND_PROCESS; } + /** + * @return {String} + */ - } - SpeechCapabilities._MAP = Object.freeze({ - 'SC_TEXT': 'TEXT', - 'SAPI_PHONEMES': 'SAPI_PHONEMES', - 'LHPLUS_PHONEMES': 'LHPLUS_PHONEMES', - 'PRE_RECORDED': 'PRE_RECORDED', - 'SILENCE': 'SILENCE', - 'FILE': 'FILE' - }); + static get TESTING() { + return AppHMIType._MAP.TESTING; + } + /** + * @return {String} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class TTSChunk extends RpcStruct { - constructor(parameters) { - super(parameters); + static get SYSTEM() { + return AppHMIType._MAP.SYSTEM; } /** - * @param {String} text - * @return {TTSChunk} - */ + * @return {String} + */ - setText(text) { - this.setParameter(TTSChunk.KEY_TEXT, text); - return this; + static get PROJECTION() { + return AppHMIType._MAP.PROJECTION; } /** - * @return {Number} - */ + * @return {String} + */ - getText() { - return this.getParameter(TTSChunk.KEY_TEXT); + static get REMOTE_CONTROL() { + return AppHMIType._MAP.REMOTE_CONTROL; } /** - * @param {SpeechCapabilities} type - * @return {TTSChunk} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - setType(type) { - this.validateType(SpeechCapabilities, type); - this.setParameter(TTSChunk.KEY_TYPE, type); - return this; + static valueForKey(key) { + return AppHMIType._valueForKey(key, AppHMIType._MAP); } /** - * @return {SpeechCapabilities} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - getType() { - return this.getObject(SpeechCapabilities, TTSChunk.KEY_TYPE); + static keyForValue(value) { + return AppHMIType._keyForValue(value, AppHMIType._MAP); } } - TTSChunk.KEY_TEXT = 'text'; - TTSChunk.KEY_TYPE = 'type'; + AppHMIType._MAP = Object.freeze({ + 'DEFAULT': 'DEFAULT', + 'COMMUNICATION': 'COMMUNICATION', + 'MEDIA': 'MEDIA', + 'MESSAGING': 'MESSAGING', + 'NAVIGATION': 'NAVIGATION', + 'INFORMATION': 'INFORMATION', + 'SOCIAL': 'SOCIAL', + 'BACKGROUND_PROCESS': 'BACKGROUND_PROCESS', + 'TESTING': 'TESTING', + 'SYSTEM': 'SYSTEM', + 'PROJECTION': 'PROJECTION', + 'REMOTE_CONTROL': 'REMOTE_CONTROL' + }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * @typedef {Enum} Language + * @property {Object} _MAP + */ - class DeviceInfo extends RpcStruct { - constructor(parameters) { - super(parameters); + class Language extends Enum { + /** + * @constructor + */ + constructor() { + super(); } /** - * @param {String} hardware - * @return {DeviceInfo} - */ + * English - US + * @return {String} + */ - setHardware(hardware) { - this.validateType(String, hardware); - this.setParameter(DeviceInfo.KEY_HARDWARE, hardware); - return this; + static get EN_US() { + return Language._MAP.EN_US; } /** - * @return {String} - */ + * Spanish - Mexico + * @return {String} + */ - getHardware() { - return this.getParameter(DeviceInfo.KEY_HARDWARE); + static get ES_MX() { + return Language._MAP.ES_MX; } /** - * @param {String} firmwareRev - * @return {DeviceInfo} - */ + * French - Canada + * @return {String} + */ - setFirmwareRev(firmwareRev) { - this.validateType(String, firmwareRev); - this.setParameter(DeviceInfo.KEY_FIRMWARE_REV, firmwareRev); - return this; + static get FR_CA() { + return Language._MAP.FR_CA; } /** - * @return {String} - */ + * German - Germany + * @return {String} + */ - getFirmwareRev() { - return this.getParameter(DeviceInfo.KEY_FIRMWARE_REV); + static get DE_DE() { + return Language._MAP.DE_DE; } /** - * @param {String} os - * @return {DeviceInfo} - */ + * Spanish - Spain + * @return {String} + */ - setOs(os) { - this.validateType(String, os); - this.setParameter(DeviceInfo.KEY_OS, os); - return this; + static get ES_ES() { + return Language._MAP.ES_ES; } /** - * @return {String} - */ + * English - GB + * @return {String} + */ - getOs() { - return this.getParameter(DeviceInfo.KEY_OS); + static get EN_GB() { + return Language._MAP.EN_GB; } /** - * @param {String} osVersion - * @return {DeviceInfo} - */ + * Russian - Russia + * @return {String} + */ - setOsVersion(osVersion) { - this.validateType(String, osVersion); - this.setParameter(DeviceInfo.KEY_OS_VERSION, osVersion); - return this; + static get RU_RU() { + return Language._MAP.RU_RU; } /** - * @return {String} - */ + * Turkish - Turkey + * @return {String} + */ - getOsVersion() { - return this.getParameter(DeviceInfo.KEY_OS_VERSION); + static get TR_TR() { + return Language._MAP.TR_TR; } /** - * @param {String} carrier - * @return {DeviceInfo} - */ + * Polish - Poland + * @return {String} + */ - setCarrier(carrier) { - this.validateType(String, carrier); - this.setParameter(DeviceInfo.KEY_CARRIER, carrier); - return this; + static get PL_PL() { + return Language._MAP.PL_PL; } /** - * @return {String} - */ + * French - France + * @return {String} + */ - getCarrier() { - return this.getParameter(DeviceInfo.KEY_CARRIER); + static get FR_FR() { + return Language._MAP.FR_FR; } /** - * @param {Number} maxNumberRFCOMMPorts - * @return {DeviceInfo} - */ + * Italian - Italy + * @return {String} + */ - setMaxNumberRFCOMMPorts(maxNumberRFCOMMPorts) { - this.validateType(Number, maxNumberRFCOMMPorts); - this.setParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS, maxNumberRFCOMMPorts); - return this; + static get IT_IT() { + return Language._MAP.IT_IT; } /** - * @return {Number} - */ + * Swedish - Sweden + * @return {String} + */ - getMaxNumberRFCOMMPorts() { - return this.getParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS); + static get SV_SE() { + return Language._MAP.SV_SE; } + /** + * Portuguese - Portugal + * @return {String} + */ - } - - DeviceInfo.KEY_HARDWARE = 'hardware'; - DeviceInfo.KEY_FIRMWARE_REV = 'firmwareRev'; - DeviceInfo.KEY_OS = 'os'; - DeviceInfo.KEY_OS_VERSION = 'osVersion'; - DeviceInfo.KEY_CARRIER = 'carrier'; - DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS = 'maxNumberRFCOMMPorts'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class AppInfo extends RpcStruct { - constructor(parameters) { - super(parameters); + static get PT_PT() { + return Language._MAP.PT_PT; } /** - * @param {String} appDisplayName - * @return {AppInfo} - */ + * Dutch (Standard) - Netherlands + * @return {String} + */ - setAppDisplayName(appDisplayName) { - this.setParameter(AppInfo.KEY_APP_DISPLAY_NAME, appDisplayName); - return this; + static get NL_NL() { + return Language._MAP.NL_NL; } /** - * @return {String} - */ + * English - Australia + * @return {String} + */ - getAppDisplayName() { - return this.getParameter(AppInfo.KEY_APP_DISPLAY_NAME); + static get EN_AU() { + return Language._MAP.EN_AU; } /** - * @param {String} appBundleID - * @return {AppInfo} - */ + * Mandarin - China + * @return {String} + */ - setAppBundleID(appBundleID) { - this.setParameter(AppInfo.KEY_APP_BUNDLE_ID, appBundleID); - return this; + static get ZH_CN() { + return Language._MAP.ZH_CN; } /** - * @return {String} - */ + * Mandarin - Taiwan + * @return {String} + */ - getAppBundleID() { - return this.getParameter(AppInfo.KEY_APP_BUNDLE_ID); + static get ZH_TW() { + return Language._MAP.ZH_TW; } /** - * @param {String} appVersion - * @return {AppInfo} - */ + * Japanese - Japan + * @return {String} + */ - setAppVersion(appVersion) { - this.setParameter(AppInfo.KEY_APP_VERSION, appVersion); - return this; + static get JA_JP() { + return Language._MAP.JA_JP; } /** - * @return {String} - */ + * Arabic - Saudi Arabia + * @return {String} + */ - getAppVersion() { - return this.getParameter(AppInfo.KEY_APP_VERSION); + static get AR_SA() { + return Language._MAP.AR_SA; } /** - * @param {String} appIcon string of the app icon file name - * @return {AppInfo} - */ + * Korean - South Korea + * @return {String} + */ - setAppIcon(appIcon) { - this.setParameter(AppInfo.KEY_APP_ICON, appIcon); - return this; + static get KO_KR() { + return Language._MAP.KO_KR; } /** - * @return {String} - */ + * Portuguese - Brazil + * @return {String} + */ - getAppIcon() { - return this.getParameter(AppInfo.KEY_APP_ICON); + static get PT_BR() { + return Language._MAP.PT_BR; } + /** + * Czech - Czech Republic + * @return {String} + */ - } - - AppInfo.KEY_APP_DISPLAY_NAME = 'appDisplayName'; - AppInfo.KEY_APP_BUNDLE_ID = 'appBundleID'; - AppInfo.KEY_APP_VERSION = 'appVersion'; - AppInfo.KEY_APP_ICON = 'appIcon'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class RGBColor extends RpcStruct { - constructor(parameters) { - super(parameters); + static get CS_CZ() { + return Language._MAP.CS_CZ; } /** - * @param {Number} redValue - * @return {RGBColor} - */ + * Danish - Denmark + * @return {String} + */ - setRedValue(redValue) { - this.setParameter(RGBColor.KEY_RED, redValue); - return this; + static get DA_DK() { + return Language._MAP.DA_DK; } /** - * @return {Number} - */ + * Norwegian - Norway + * @return {String} + */ - getRedValue() { - return this.getParameter(RGBColor.KEY_RED); + static get NO_NO() { + return Language._MAP.NO_NO; } /** - * @param {Number} greenValue - * @return {RGBColor} - */ + * Dutch (Flemish) - Belgium + * @return {String} + */ - setGreenValue(greenValue) { - this.setParameter(RGBColor.KEY_GREEN, greenValue); - return this; + static get NL_BE() { + return Language._MAP.NL_BE; } /** - * @return {Number} - */ + * Greek - Greece + * @return {String} + */ - getGreenValue() { - return this.getParameter(RGBColor.KEY_GREEN); + static get EL_GR() { + return Language._MAP.EL_GR; } /** - * @param {Number} blueValue - * @return {RGBColor} - */ + * Hungarian - Hungary + * @return {String} + */ - setBlueValue(blueValue) { - this.setParameter(RGBColor.KEY_BLUE, blueValue); - return this; + static get HU_HU() { + return Language._MAP.HU_HU; } /** - * @return {Number} - */ + * Finnish - Finland + * @return {String} + */ - getBlueValue() { - return this.getParameter(RGBColor.KEY_BLUE); + static get FI_FI() { + return Language._MAP.FI_FI; } + /** + * Slovak - Slovakia + * @return {String} + */ - } - - RGBColor.KEY_RED = 'red'; - RGBColor.KEY_GREEN = 'green'; - RGBColor.KEY_BLUE = 'blue'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class TemplateColorScheme extends RpcStruct { - constructor(parameters) { - super(parameters); + static get SK_SK() { + return Language._MAP.SK_SK; } /** - * @param {RGBColor} primaryColor - * @return {TemplateColorScheme} - */ + * English - India + * @return {String} + */ - setPrimaryColor(primaryColor) { - this.validateType(RGBColor, primaryColor); - this.setParameter(TemplateColorScheme.KEY_PRIMARY_COLOR, primaryColor); - return this; + static get EN_IN() { + return Language._MAP.EN_IN; } /** - * @return {RGBColor} - */ + * Thai - Thailand + * @return {String} + */ - getPrimaryColor() { - return this.getObject(RGBColor, TemplateColorScheme.KEY_PRIMARY_COLOR); + static get TH_TH() { + return Language._MAP.TH_TH; } /** - * @param {RGBColor} secondaryColor - * @return {TemplateColorScheme} - */ + * English - Middle East + * @return {String} + */ - setSecondaryColor(secondaryColor) { - this.validateType(RGBColor, secondaryColor); - this.setParameter(TemplateColorScheme.KEY_SECONDARY_COLOR, secondaryColor); - return this; + static get EN_SA() { + return Language._MAP.EN_SA; } /** - * @return {RGBColor} - */ + * Hebrew - Israel + * @return {String} + */ - getSecondaryColor() { - return this.getObject(RGBColor, TemplateColorScheme.KEY_SECONDARY_COLOR); - } + static get HE_IL() { + return Language._MAP.HE_IL; + } /** - * @param {RGBColor} backgroundColor - * @return {TemplateColorScheme} - */ + * Romanian - Romania + * @return {String} + */ - setBackgroundColor(backgroundColor) { - this.validateType(RGBColor, backgroundColor); - this.setParameter(TemplateColorScheme.KEY_BACKGROUND_COLOR, backgroundColor); - return this; + static get RO_RO() { + return Language._MAP.RO_RO; } /** - * @return {RGBColor} - */ + * Ukrainian - Ukraine + * @return {String} + */ - getBackgroundColor() { - return this.getObject(RGBColor, TemplateColorScheme.KEY_BACKGROUND_COLOR); + static get UK_UA() { + return Language._MAP.UK_UA; + } + /** + * Indonesian - Indonesia + * @return {String} + */ + + + static get ID_ID() { + return Language._MAP.ID_ID; + } + /** + * Vietnamese - Vietnam + * @return {String} + */ + + + static get VI_VN() { + return Language._MAP.VI_VN; + } + /** + * Malay - Malaysia + * @return {String} + */ + + + static get MS_MY() { + return Language._MAP.MS_MY; + } + /** + * Hindi - India + * @return {String} + */ + + + static get HI_IN() { + return Language._MAP.HI_IN; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return Language._valueForKey(key, Language._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return Language._keyForValue(value, Language._MAP); } } - TemplateColorScheme.KEY_PRIMARY_COLOR = 'primaryColor'; - TemplateColorScheme.KEY_SECONDARY_COLOR = 'secondaryColor'; - TemplateColorScheme.KEY_BACKGROUND_COLOR = 'backgroundColor'; + Language._MAP = Object.freeze({ + 'EN_US': 'EN-US', + 'ES_MX': 'ES-MX', + 'FR_CA': 'FR-CA', + 'DE_DE': 'DE-DE', + 'ES_ES': 'ES-ES', + 'EN_GB': 'EN-GB', + 'RU_RU': 'RU-RU', + 'TR_TR': 'TR-TR', + 'PL_PL': 'PL-PL', + 'FR_FR': 'FR-FR', + 'IT_IT': 'IT-IT', + 'SV_SE': 'SV-SE', + 'PT_PT': 'PT-PT', + 'NL_NL': 'NL-NL', + 'EN_AU': 'EN-AU', + 'ZH_CN': 'ZH-CN', + 'ZH_TW': 'ZH-TW', + 'JA_JP': 'JA-JP', + 'AR_SA': 'AR-SA', + 'KO_KR': 'KO-KR', + 'PT_BR': 'PT-BR', + 'CS_CZ': 'CS-CZ', + 'DA_DK': 'DA-DK', + 'NO_NO': 'NO-NO', + 'NL_BE': 'NL-BE', + 'EL_GR': 'EL-GR', + 'HU_HU': 'HU-HU', + 'FI_FI': 'FI-FI', + 'SK_SK': 'SK-SK', + 'EN_IN': 'EN-IN', + 'TH_TH': 'TH-TH', + 'EN_SA': 'EN-SA', + 'HE_IL': 'HE-IL', + 'RO_RO': 'RO-RO', + 'UK_UA': 'UK-UA', + 'ID_ID': 'ID-ID', + 'VI_VN': 'VI-VN', + 'MS_MY': 'MS-MY', + 'HI_IN': 'HI-IN' + }); /* * Copyright (c) 2019, Livio, Inc. @@ -2657,928 +2626,793 @@ * POSSIBILITY OF SUCH DAMAGE. */ /** - * @typedef {Enum} Language - * @property {Object} _MAP + * @typedef {Object} RpcMessage + * @property {RpcType} rpcType */ - class Language extends Enum { - /** - * @constructor - */ - constructor() { - super(); + class RpcMessage extends RpcStruct { + /* + { + "rpcType": "Request", + "functionName": "RegisterAppInterface", + "coorelationID": "320948", + "isEncrypted": false, + "parameters": { + "appName": "Hello" + }, + "bulkData": "...", } - /** - * @return {String} - */ - + */ - static get EN_SA() { - return Language._MAP.EN_SA; + /** + * @constructor + */ + constructor(store = {}) { + super(store.parameters); + this._isEncrypted = false; + this._rpcType = store.rpcType; + this._functionName = store.functionName; + this._correlationID = store.correlationID; + this.setBulkData(store.bulkData); } /** - * @return {String} - */ + * @return {RpcType} + */ - static get HE_IL() { - return Language._MAP.HE_IL; + getRPCType() { + return this._rpcType; } /** - * @return {String} - */ + * @param {RpcType} type + * @return {RpcMessage} + */ - static get RO_RO() { - return Language._MAP.RO_RO; + setRPCType(type) { + this._rpcType = type; + return this; } /** - * @return {String} - */ + * @return {FunctionID} type + */ - static get UK_UA() { - return Language._MAP.UK_UA; + getFunctionName() { + return this._functionName; } /** - * @return {String} - */ + * @param {FunctionID} name + * @return {RpcMessage} + */ - static get ID_ID() { - return Language._MAP.ID_ID; + setFunctionName(name) { + if (typeof name !== 'string') { + this._functionName = FunctionID.keyForValue(name); + } else { + this._functionName = name; + } + + return this; } /** - * @return {String} - */ + * @return {String} type + */ - static get VI_VN() { - return Language._MAP.VI_VN; + getCorrelationId() { + return this._correlationID; } /** - * @return {String} - */ + * @param {String} name + * @return {RpcMessage} + */ - static get MS_MY() { - return Language._MAP.MS_MY; + setCorrelationId(id) { + this._correlationID = id; + return this; } /** - * @return {String} - */ + * @return {Uint8Array} data + */ - static get HI_IN() { - return Language._MAP.HI_IN; + getBulkData() { + return this._bulkData; } /** - * @return {String} - */ + * @param {UInt8Array} data + * @return {RpcMessage} + */ - static get NL_BE() { - return Language._MAP.NL_BE; + setBulkData(data = null) { + if (data !== null) { + this._bulkData = data.slice(0); + } else { + this._bulkData = null; + } + + return this; } /** - * @return {String} - */ + * @return {Boolean} + */ - static get EL_GR() { - return Language._MAP.EL_GR; + getIsEncrypted() { + return this._isEncrypted; } /** - * @return {String} - */ + * @param {Boolean} bool + * @return {RpcMessage} + */ - static get HU_HU() { - return Language._MAP.HU_HU; + setIsEncrypted(bool) { + this._isEncrypted = bool; + return this; } - /** - * @return {String} - */ + } - static get FI_FI() { - return Language._MAP.FI_FI; + /* + * Copyright (c) 2019, Livio, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Livio Inc. nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + /** + * @typedef {Enum} RpcType + * @property {Object} _MAP + */ + + class RpcType extends Enum { + /** + * @constructor + */ + constructor() { + super(); } /** - * @return {String} + * @return {Number} */ - static get SK_SK() { - return Language._MAP.SK_SK; + static get NOTIFICATION() { + return RpcType._MAP.NOTIFICATION; } /** - * @return {String} + * @return {Number} */ - static get EN_US() { - return Language._MAP.EN_US; + static get RESPONSE() { + return RpcType._MAP.RESPONSE; } /** - * @return {String} + * @return {Number} */ - static get ES_MX() { - return Language._MAP.ES_MX; + static get REQUEST() { + return RpcType._MAP.REQUEST; } /** - * @return {String} - */ + * Get the value for the given enum key + * @param value - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - static get FR_CA() { - return Language._MAP.FR_CA; + static valueForKey(key) { + return RpcType._valueForKey(key, RpcType._MAP); } /** - * @return {String} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - static get DE_DE() { - return Language._MAP.DE_DE; + static keyForValue(value) { + return RpcType._keyForValue(value, RpcType._MAP); } - /** - * @return {String} - */ + } - static get ES_ES() { - return Language._MAP.ES_ES; - } - /** - * @return {String} - */ + RpcType._MAP = Object.freeze({ + 'NOTIFICATION': 0x2, + 'RESPONSE': 0x1, + 'REQUEST': 0x0 + }); + /* + * Copyright (c) 2019, Livio, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Livio Inc. nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ - static get EN_GB() { - return Language._MAP.EN_GB; + class RpcRequest extends RpcMessage { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setRPCType(RpcType.REQUEST); + this._promise = null; } /** - * @return {String} - */ + * @return {Promise} + */ - static get RU_RU() { - return Language._MAP.RU_RU; + getOnRPCResponsePromise() { + return this._promise; } /** - * @return {String} - */ + * @param {Promise} promise + * @return {RpcMessage} + */ - static get TR_TR() { - return Language._MAP.TR_TR; + setOnRPCResponsePromise(promise) { + this.validateType(Promise, promise); + this._promise = promise; + return this; } - /** - * @return {String} - */ + } + + /* eslint-disable camelcase */ + /** + * Various information about connecting device. + */ - static get PL_PL() { - return Language._MAP.PL_PL; - } + class DeviceInfo extends RpcStruct { /** - * @return {String} + * @constructor */ - - - static get FR_FR() { - return Language._MAP.FR_FR; + constructor(parameters) { + super(parameters); } /** - * @return {String} + * @param {String} hardware - Device model + * @return {DeviceInfo} */ - static get IT_IT() { - return Language._MAP.IT_IT; + setHardware(hardware) { + this.setParameter(DeviceInfo.KEY_HARDWARE, hardware); + return this; } /** * @return {String} */ - static get SV_SE() { - return Language._MAP.SV_SE; + getHardware() { + return this.getParameter(DeviceInfo.KEY_HARDWARE); } /** - * @return {String} + * @param {String} rev - Device firmware revision + * @return {DeviceInfo} */ - static get PT_PT() { - return Language._MAP.PT_PT; + setFirmwareRev(rev) { + this.setParameter(DeviceInfo.KEY_FIRMWARE_REV, rev); + return this; } /** * @return {String} */ - static get NL_NL() { - return Language._MAP.NL_NL; + getFirmwareRev() { + return this.getParameter(DeviceInfo.KEY_FIRMWARE_REV); } /** - * @return {String} + * @param {String} os - Device OS + * @return {DeviceInfo} */ - static get EN_AU() { - return Language._MAP.EN_AU; + setOs(os) { + this.setParameter(DeviceInfo.KEY_OS, os); + return this; } /** * @return {String} */ - static get ZH_CN() { - return Language._MAP.ZH_CN; + getOs() { + return this.getParameter(DeviceInfo.KEY_OS); } /** - * @return {String} + * @param {String} version - Device OS version + * @return {DeviceInfo} */ - static get ZH_TW() { - return Language._MAP.ZH_TW; + setOsVersion(version) { + this.setParameter(DeviceInfo.KEY_OS_VERSION, version); + return this; } /** * @return {String} */ - static get JA_JP() { - return Language._MAP.JA_JP; + getOsVersion() { + return this.getParameter(DeviceInfo.KEY_OS_VERSION); } /** - * @return {String} + * @param {String} carrier - Device mobile carrier (if applicable) + * @return {DeviceInfo} */ - static get AR_SA() { - return Language._MAP.AR_SA; + setCarrier(carrier) { + this.setParameter(DeviceInfo.KEY_CARRIER, carrier); + return this; } /** * @return {String} */ - static get KO_KR() { - return Language._MAP.KO_KR; + getCarrier() { + return this.getParameter(DeviceInfo.KEY_CARRIER); } /** - * @return {String} + * @param {Number} ports - Omitted if connected not via BT. + * @return {DeviceInfo} */ - static get PT_BR() { - return Language._MAP.PT_BR; + setMaxNumberRFCOMMPorts(ports) { + this.setParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS, ports); + return this; } /** - * @return {String} + * @return {Number} */ - static get CS_CZ() { - return Language._MAP.CS_CZ; + getMaxNumberRFCOMMPorts() { + return this.getParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS); } - /** - * @return {String} - */ + } - static get DA_DK() { - return Language._MAP.DA_DK; - } - /** - * @return {String} - */ + DeviceInfo.KEY_HARDWARE = 'hardware'; + DeviceInfo.KEY_FIRMWARE_REV = 'firmwareRev'; + DeviceInfo.KEY_OS = 'os'; + DeviceInfo.KEY_OS_VERSION = 'osVersion'; + DeviceInfo.KEY_CARRIER = 'carrier'; + DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS = 'maxNumberRFCOMMPorts'; + /* eslint-disable camelcase */ + /** + * Establishes an interface with a mobile application. Before registerAppInterface no other commands will be + * accepted/executed. + */ - static get NO_NO() { - return Language._MAP.NO_NO; - } + class RegisterAppInterface extends RpcRequest { /** - * @return {String} + * @constructor */ - - - static get EN_IN() { - return Language._MAP.EN_IN; + constructor(store) { + super(store); + this.setFunctionName(FunctionID.RegisterAppInterface); } /** - * @return {String} + * @param {String} fullAppId + * @return {RegisterAppInterface} */ - static get TH_TH() { - return Language._MAP.TH_TH; - } - /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ - - - static valueForKey(key) { - return Language._valueForKey(key, Language._MAP); - } - /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ - - - static keyForValue(value) { - return Language._keyForValue(value, Language._MAP); - } - - } - - Language._MAP = Object.freeze({ - 'EN_SA': 'EN-SA', - 'HE_IL': 'HE-IL', - 'RO_RO': 'RO-RO', - 'UK_UA': 'UK-UA', - 'ID_ID': 'ID-ID', - 'VI_VN': 'VI-VN', - 'MS_MY': 'MS-MY', - 'HI_IN': 'HI-IN', - 'NL_BE': 'NL-BE', - 'EL_GR': 'EL-GR', - 'HU_HU': 'HU-HU', - 'FI_FI': 'FI-FI', - 'SK_SK': 'SK-SK', - 'EN_US': 'EN-US', - 'ES_MX': 'ES-MX', - 'FR_CA': 'FR-CA', - 'DE_DE': 'DE-DE', - 'ES_ES': 'ES-ES', - 'EN_GB': 'EN-GB', - 'RU_RU': 'RU-RU', - 'TR_TR': 'TR-TR', - 'PL_PL': 'PL-PL', - 'FR_FR': 'FR-FR', - 'IT_IT': 'IT-IT', - 'SV_SE': 'SV-SE', - 'PT_PT': 'PT-PT', - 'NL_NL': 'NL-NL', - 'EN_AU': 'EN-AU', - 'ZH_CN': 'ZH-CN', - 'ZH_TW': 'ZH-TW', - 'JA_JP': 'JA-JP', - 'AR_SA': 'AR-SA', - 'KO_KR': 'KO-KR', - 'PT_BR': 'PT-BR', - 'CS_CZ': 'CS-CZ', - 'DA_DK': 'DA-DK', - 'NO_NO': 'NO-NO', - 'EN_IN': 'EN-IN', - 'TH_TH': 'TH-TH' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} AppHMIType - * @property {Object} _MAP - */ - - class AppHMIType extends Enum { - constructor() { - super(); - } - /** - * @return {String} - */ - - - static get DEFAULT() { - return AppHMIType._MAP.DEFAULT; - } - /** - * @return {String} - */ - - - static get COMMUNICATION() { - return AppHMIType._MAP.COMMUNICATION; - } - /** - * @return {String} - */ - - - static get MEDIA() { - return AppHMIType._MAP.MEDIA; - } - /** - * @return {String} - */ - - - static get MESSAGING() { - return AppHMIType._MAP.MESSAGING; - } - /** - * @return {String} - */ - - - static get NAVIGATION() { - return AppHMIType._MAP.NAVIGATION; - } - /** - * @return {String} - */ - - - static get INFORMATION() { - return AppHMIType._MAP.INFORMATION; - } - /** - * @return {String} - */ + setFullAppId(fullAppId) { + this.validateType(String, fullAppId); + if (fullAppId !== null) { + fullAppId = fullAppId.toLowerCase(); + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, fullAppId); + let appID; - static get SOCIAL() { - return AppHMIType._MAP.SOCIAL; - } - /** - * @return {String} - */ + if (fullAppId.length <= RegisterAppInterface.APP_ID_MAX_LENGTH) { + appID = fullAppId; + } else { + appID = fullAppId.replace('-', '').substring(0, RegisterAppInterface.APP_ID_MAX_LENGTH); + } + this._setAppId(appID); + } else { + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, null); + } - static get BACKGROUND_PROCESS() { - return AppHMIType._MAP.BACKGROUND_PROCESS; + return this; } /** - * @return {String} + * @return {String} the app id */ - static get TESTING() { - return AppHMIType._MAP.TESTING; + getFullAppId() { + return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID); } /** - * @return {String} + * @param {String} appId - This method should not be accessed directly by developers. Only set the full ID and this + * param will be set. + * @return {RegisterAppInterface} */ - static get SYSTEM() { - return AppHMIType._MAP.SYSTEM; + _setAppId(appId) { + this.validateType(String, appId); + this.setParameter(RegisterAppInterface.KEY_APP_ID, appId); + return this; } /** - * @return {String} + * @return {String} the app id */ - static get PROJECTION() { - return AppHMIType._MAP.PROJECTION; + getAppId() { + return this.getParameter(RegisterAppInterface.KEY_APP_ID); } /** - * @return {String} + * @param {SdlMsgVersion} version - See SyncMsgVersion + * @return {RegisterAppInterface} */ - static get REMOTE_CONTROL() { - return AppHMIType._MAP.REMOTE_CONTROL; - } - /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ - - - static valueForKey(key) { - return AppHMIType._valueForKey(key, AppHMIType._MAP); - } - /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ - - - static keyForValue(value) { - return AppHMIType._keyForValue(value, AppHMIType._MAP); - } - - } - - AppHMIType._MAP = Object.freeze({ - 'DEFAULT': 'DEFAULT', - 'COMMUNICATION': 'COMMUNICATION', - 'MEDIA': 'MEDIA', - 'MESSAGING': 'MESSAGING', - 'NAVIGATION': 'NAVIGATION', - 'INFORMATION': 'INFORMATION', - 'SOCIAL': 'SOCIAL', - 'BACKGROUND_PROCESS': 'BACKGROUND_PROCESS', - 'TESTING': 'TESTING', - 'SYSTEM': 'SYSTEM', - 'PROJECTION': 'PROJECTION', - 'REMOTE_CONTROL': 'REMOTE_CONTROL' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - class RegisterAppInterface extends RpcRequest { - constructor(store) { - super(store); - this.setFunctionName(FunctionID.RegisterAppInterface); - } - /** - * @param {SdlMsgVersion} The max RPC Spec version supported by this library - * @return {RegisterAppInterface} - */ - - - setSdlMsgVersion(sdlMsgVersion) { - this.validateType(SdlMsgVersion, sdlMsgVersion); - this.setParameter(RegisterAppInterface.KEY_SDL_MSG_VERSION, sdlMsgVersion); + setSdlMsgVersion(version) { + this.validateType(SdlMsgVersion, version); + this.setParameter(RegisterAppInterface.KEY_SDL_MSG_VERSION, version); return this; } /** - * @return {SdlMsgVersion} - */ + * @return {SdlMsgVersion} + */ getSdlMsgVersion() { return this.getObject(SdlMsgVersion, RegisterAppInterface.KEY_SDL_MSG_VERSION); } /** - * @param {String} appName the name of the app that is registering - * @return {RegisterAppInterface} - */ + * @param {String} name - The mobile application name, e.g. "My SDL App". Needs to be unique over all applications + * from the same device. May not be empty. May not start with a new line character. May not + * interfere with any name or synonym of previously registered applications from the same + * device and any predefined blacklist of words (global commands) Additional applications + * with the same name from the same device will be rejected. Only characters from char set + * @return {RegisterAppInterface} + */ - setAppName(appName) { - this.validateType(String, appName); - this.setParameter(RegisterAppInterface.KEY_APP_NAME, appName); + setAppName(name) { + this.setParameter(RegisterAppInterface.KEY_APP_NAME, name); return this; } /** - * @return {String} the app name - */ + * @return {String} + */ getAppName() { return this.getParameter(RegisterAppInterface.KEY_APP_NAME); } /** - * @param {Array} ttsNames TTS string for VR recognition of the mobile application name, e.g. "My S D L App". - * Meant to overcome any failing on speech engine in properly pronouncing / understanding - * app name. Needs to be unique over all applications from the same device. May not be - * empty. May not start with a new line character. Only characters from char set - * @return {RegisterAppInterface} - */ + * @param {TTSChunk[]} name - TTS string for VR recognition of the mobile application name, e.g. "My S D L App". + * Meant to overcome any failing on speech engine in properly pronouncing / understanding + * app name. Needs to be unique over all applications from the same device. May not be + * empty. May not start with a new line character. Only characters from char set + * @return {RegisterAppInterface} + */ - setTtsName(ttsNames) { - this.setParameter(RegisterAppInterface.KEY_TTS_NAME, ttsNames); + setTtsName(name) { + this.validateType(TTSChunk, name, true); + this.setParameter(RegisterAppInterface.KEY_TTS_NAME, name); return this; } /** - * @return {Array} - */ + * @return {TTSChunk[]} + */ getTtsName() { return this.getObject(TTSChunk, RegisterAppInterface.KEY_TTS_NAME); } /** - * @param {String} ngnppName Provides an abbreviated version of the app name (if needed), that will be displayed - * on the NGN media screen. If not provided, the appName is used instead (and - * will be truncated if too long)Only characters from char set. - * @return {RegisterAppInterface} - */ + * @param {String} name - Provides an abbreviated version of the app name (if needed), that will be displayed on the + * NGN media screen. If not provided, the appName is used instead (and will be truncated if + * too long) Only characters from char set + * @return {RegisterAppInterface} + */ - setNgnMediaScreenAppName(ngnppName) { - this.validateType(String, ngnppName); - this.setParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME, ngnppName); + setNgnMediaScreenAppName(name) { + this.setParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME, name); return this; } /** - * @return {String} an abbreviated version of the app name - */ + * @return {String} + */ getNgnMediaScreenAppName() { return this.getParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME); } /** - * @param {Array} vrSynonyms Defines an additional voice recognition command. May not - * interfere with any app name of previously registered applications - * from the same device and any predefined blacklist of words (global - * commands)Only characters from char set - * @return {RegisterAppInterface} - */ + * @param {String[]} synonyms - Defines an additional voice recognition command. May not interfere with any app name + * of previously registered applications from the same device and any predefined + * blacklist of words (global commands) Only characters from char set + * @return {RegisterAppInterface} + */ - setVrSynonyms(vrSynonyms) { - this.setParameter(RegisterAppInterface.KEY_VR_SYNONYMS, vrSynonyms); + setVrSynonyms(synonyms) { + this.setParameter(RegisterAppInterface.KEY_VR_SYNONYMS, synonyms); return this; } /** - * @return {Array} - */ + * @return {String[]} + */ getVrSynonyms() { return this.getParameter(RegisterAppInterface.KEY_VR_SYNONYMS); } /** - * @param {Boolean} isMediaApplication Indicates if the application is a media or a non-media application. - * Only media applications will be able to stream audio to the module - * that is audible outside of the BT media source. - * @return {RegisterAppInterface} - */ + * @param {Boolean} application - Indicates if the application is a media or a non-media application. Only media + * applications will be able to stream audio to the module that is audible outside of + * the BT media source. + * @return {RegisterAppInterface} + */ - setIsMediaApplication(isMediaApplication) { - this.setParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION, isMediaApplication); + setIsMediaApplication(application) { + this.setParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION, application); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ getIsMediaApplication() { return this.getParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION); } /** - * @param {Language} languageDesired - * @return {RegisterAppInterface} - */ + * @param {Language} desired - See Language Current app's expected VR+TTS language If there is a mismatch with the + * module, the app will be able to change this registration with changeRegistration + * prior to app being brought into focus. + * @return {RegisterAppInterface} + */ - setLanguageDesired(languageDesired) { - this.validateType(Language, languageDesired); - this.setParameter(RegisterAppInterface.KEY_LANGUAGE_DESIRED, languageDesired); + setLanguageDesired(desired) { + this.validateType(Language, desired); + this.setParameter(RegisterAppInterface.KEY_LANGUAGE_DESIRED, desired); return this; } /** - * @return {Language} - */ + * @return {Language} + */ getLanguageDesired() { return this.getObject(Language, RegisterAppInterface.KEY_LANGUAGE_DESIRED); } /** - * @param {Language} hmiDisplayLanguageDesired - * @return {RegisterAppInterface} - */ + * @param {Language} desired - See Language Current app's expected display language If there is a mismatch with the + * module, the app will be able to change this registration with changeRegistration + * prior to app being brought into focus. + * @return {RegisterAppInterface} + */ - setHmiDisplayLanguageDesired(hmiDisplayLanguageDesired) { - this.validateType(Language, hmiDisplayLanguageDesired); - this.setParameter(RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED, hmiDisplayLanguageDesired); + setHmiDisplayLanguageDesired(desired) { + this.validateType(Language, desired); + this.setParameter(RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED, desired); return this; } /** - * @return {Language} - */ + * @return {Language} + */ getHmiDisplayLanguageDesired() { return this.getObject(Language, RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED); } /** - * @param {Array} appHMIType - * @return {RegisterAppInterface} - */ + * @param {AppHMIType[]} type - See AppHMIType List of all applicable app HMI types stating which HMI + * classifications to be given to the app. + * @return {RegisterAppInterface} + */ - setAppHmiType(appHMIType) { - // TODO make validate type accept arrays - // this.validateType(AppHMIType, appHMIType); - this.setParameter(RegisterAppInterface.KEY_APP_HMI_TYPE, appHMIType); + setAppHMIType(type) { + this.validateType(AppHMIType, type, true); + this.setParameter(RegisterAppInterface.KEY_APP_HMI_TYPE, type); return this; } /** - * @return {Array} - */ + * @return {AppHMIType[]} + */ - getAppHmiType() { + getAppHMIType() { return this.getObject(AppHMIType, RegisterAppInterface.KEY_APP_HMI_TYPE); } /** - * @param {String} hashID the hash ID - * @return {RegisterAppInterface} - */ + * @param {String} id - ID used to uniquely identify current state of all app data that can persist through + * connection cycles (e.g. ignition cycles). This registered data (commands, submenus, choice + * sets, etc.) can be reestablished without needing to explicitly reregister each piece. If + * omitted, then the previous state of an app's commands, etc. will not be restored. When + * sending hashID, all RegisterAppInterface parameters should still be provided (e.g. ttsName, + * etc.). + * @return {RegisterAppInterface} + */ - setHashID(hashID) { - this.validateType(String, hashID); - this.setParameter(RegisterAppInterface.KEY_HASH_ID, hashID); + setHashID(id) { + this.setParameter(RegisterAppInterface.KEY_HASH_ID, id); return this; } /** - * @return {String} the hash ID - */ + * @return {String} + */ getHashID() { return this.getParameter(RegisterAppInterface.KEY_HASH_ID); } /** - * @param {DeviceInfo} deviceInfo + * @param {DeviceInfo} info - See DeviceInfo. * @return {RegisterAppInterface} */ - setDeviceInfo(deviceInfo) { - this.validateType(DeviceInfo, deviceInfo); - this.setParameter(RegisterAppInterface.KEY_DEVICE_INFO, deviceInfo); + setDeviceInfo(info) { + this.validateType(DeviceInfo, info); + this.setParameter(RegisterAppInterface.KEY_DEVICE_INFO, info); return this; } /** - * @return {DeviceInfo} - */ + * @return {DeviceInfo} + */ getDeviceInfo() { return this.getObject(DeviceInfo, RegisterAppInterface.KEY_DEVICE_INFO); } /** - * @param {String} appName This method should not be accessed directly by developers. Only set the full ID and this param will be set. - * @return {RegisterAppInterface} - */ - - - _setAppId(appId) { - this.validateType(String, appId); - this.setParameter(RegisterAppInterface.KEY_APP_ID, appId); - return this; - } - /** - * @return {String} the app id - */ - - - getAppId() { - return this.getParameter(RegisterAppInterface.KEY_APP_ID); - } - /** - * @param {String} fullAppId - * @return {RegisterAppInterface} - */ - - - setFullAppId(fullAppId) { - this.validateType(String, fullAppId); - - if (fullAppId !== null) { - fullAppId = fullAppId.toLowerCase(); - this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, fullAppId); - let appId; - - if (fullAppId.length <= RegisterAppInterface.APP_ID_MAX_LENGTH) { - appId = fullAppId; - } else { - appId = fullAppId.replace('-', '').substring(0, RegisterAppInterface.APP_ID_MAX_LENGTH); - } + * @param {String} id - ID used to validate app with policy table entries + * @return {RegisterAppInterface} + */ - this._setAppId(appId); - } else { - this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, null); - } + setFullAppID(id) { + this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, id); return this; } /** - * @return {String} the app id - */ + * @return {String} + */ - getFullAppId() { + getFullAppID() { return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID); } /** - * @param {AppInfo} appInfo + * @param {AppInfo} info - See AppInfo. * @return {RegisterAppInterface} */ - setAppInfo(appInfo) { - this.validateType(AppInfo, appInfo); - this.setParameter(RegisterAppInterface.KEY_APP_INFO, appInfo); + setAppInfo(info) { + this.validateType(AppInfo, info); + this.setParameter(RegisterAppInterface.KEY_APP_INFO, info); return this; } /** - * @return {AppInfo} - */ + * @return {AppInfo} + */ getAppInfo() { return this.getObject(AppInfo, RegisterAppInterface.KEY_APP_INFO); } /** - * @param {TemplateColorScheme} dayColorScheme + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. * @return {RegisterAppInterface} */ - setDayColorScheme(dayColorScheme) { - this.validateType(TemplateColorScheme, dayColorScheme); - this.setParameter(RegisterAppInterface.KEY_DAY_COLOR_SCHEME, dayColorScheme); + setDayColorScheme(scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(RegisterAppInterface.KEY_DAY_COLOR_SCHEME, scheme); return this; } /** - * @return {TemplateColorScheme} - */ + * @return {TemplateColorScheme} + */ getDayColorScheme() { return this.getObject(TemplateColorScheme, RegisterAppInterface.KEY_DAY_COLOR_SCHEME); } /** - * @param {TemplateColorScheme} nightColorScheme + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. * @return {RegisterAppInterface} */ - setNightColorScheme(nightColorScheme) { - this.validateType(TemplateColorScheme, nightColorScheme); - this.setParameter(RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME, nightColorScheme); + setNightColorScheme(scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME, scheme); return this; } /** - * @return {TemplateColorScheme} - */ + * @return {TemplateColorScheme} + */ getNightColorScheme() { @@ -3587,7 +3421,6 @@ } - RegisterAppInterface.KEY_SYNC_MSG_VERSION = 'syncMsgVersion'; RegisterAppInterface.KEY_SDL_MSG_VERSION = 'syncMsgVersion'; RegisterAppInterface.KEY_APP_NAME = 'appName'; RegisterAppInterface.KEY_TTS_NAME = 'ttsName'; @@ -3606,37 +3439,7 @@ RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme'; RegisterAppInterface.APP_ID_MAX_LENGTH = 10; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** * @typedef {Enum} Result * @property {Object} _MAP @@ -3650,6 +3453,7 @@ super(); } /** + * The request succeeded * @return {String} */ @@ -3658,6 +3462,7 @@ return Result._MAP.SUCCESS; } /** + * The request is not supported by the headunit * @return {String} */ @@ -3666,14 +3471,16 @@ return Result._MAP.UNSUPPORTED_REQUEST; } /** + * A button that was requested for subscription is not supported under the current system. * @return {String} */ static get UNSUPPORTED_RESOURCE() { - return Result._MAP.UNSUPPORTED_REQUEST; + return Result._MAP.UNSUPPORTED_RESOURCE; } /** + * RPC is not authorized in local policy table. * @return {String} */ @@ -3682,6 +3489,9 @@ return Result._MAP.DISALLOWED; } /** + * The requested command was rejected, e.g. because mobile app is in background and cannot perform any HMI + * commands. Or an HMI command (e.g. Speak) is rejected because a higher priority HMI command (e.g. Alert) is + * playing. * @return {String} */ @@ -3690,6 +3500,8 @@ return Result._MAP.REJECTED; } /** + * A command was aborted, for example due to user interaction (e.g. user pressed button). Or an HMI command (e.g. + * Speak) is aborted because a higher priority HMI command (e.g. Alert) was requested. * @return {String} */ @@ -3698,6 +3510,9 @@ return Result._MAP.ABORTED; } /** + * A command was ignored, because the intended result is already in effect. For example, SetMediaClockTimer was + * used to pause the media clock although the clock is paused already. NOTE: potentially replaces + * SUBSCRIBED_ALREADY * @return {String} */ @@ -3706,6 +3521,8 @@ return Result._MAP.IGNORED; } /** + * The user interrupted the RPC (e.g. PerformAudioPassThru) and indicated to start over. Note, the app must issue + * the new RPC. * @return {String} */ @@ -3714,6 +3531,8 @@ return Result._MAP.RETRY; } /** + * The data may not be changed, because it is currently in use. For example when trying to delete a command set + * that is currently involved in an interaction. * @return {String} */ @@ -3722,6 +3541,7 @@ return Result._MAP.IN_USE; } /** + * The requested vehicle data is not available on this vehicle or is not published. * @return {String} */ @@ -3730,6 +3550,7 @@ return Result._MAP.VEHICLE_DATA_NOT_AVAILABLE; } /** + * Overlay reached the maximum timeout and closed. * @return {String} */ @@ -3738,6 +3559,8 @@ return Result._MAP.TIMED_OUT; } /** + * The data sent is invalid. For example: Invalid Json syntax Parameters out of bounds (number or enum range) + * Mandatory parameters not provided Parameter provided with wrong type Invalid characters Empty string * @return {String} */ @@ -3754,6 +3577,8 @@ return Result._MAP.CHAR_LIMIT_EXCEEDED; } /** + * One of the provided IDs is not valid. For example This applies to CorrelationID, SubscriptionID, CommandID, + * MenuID, etc. * @return {String} */ @@ -3762,6 +3587,7 @@ return Result._MAP.INVALID_ID; } /** + * There was a conflict with an registered name (application or menu item) or vr command * @return {String} */ @@ -3770,6 +3596,7 @@ return Result._MAP.DUPLICATE_NAME; } /** + * An command can not be executed because no application has been registered with RegisterApplication. * @return {String} */ @@ -3778,6 +3605,8 @@ return Result._MAP.APPLICATION_NOT_REGISTERED; } /** + * The requested language is currently not supported. Might be because of a mismatch of the currently active + * language on the headunit and the requested language * @return {String} */ @@ -3786,6 +3615,7 @@ return Result._MAP.WRONG_LANGUAGE; } /** + * The system could not process the request because the necessary memory couldn't be allocated * @return {String} */ @@ -3794,6 +3624,8 @@ return Result._MAP.OUT_OF_MEMORY; } /** + * There are too many requests pending (means, that the response has not been delivered, yet).There may be a + * maximum of 1000 pending requests at a time. * @return {String} */ @@ -3802,6 +3634,7 @@ return Result._MAP.TOO_MANY_PENDING_REQUESTS; } /** + * There are already too many registered applications * @return {String} */ @@ -3810,6 +3643,7 @@ return Result._MAP.TOO_MANY_APPLICATIONS; } /** + * RegisterApplication has been called again, after a RegisterApplication was successful before. * @return {String} */ @@ -3818,6 +3652,7 @@ return Result._MAP.APPLICATION_REGISTERED_ALREADY; } /** + * The RPC (e.g. SubscribeVehicleData) executed successfully but one or more items have a warning or failure. * @return {String} */ @@ -3826,6 +3661,7 @@ return Result._MAP.WARNINGS; } /** + * Provided data is valid but something went wrong in the lower layers. * @return {String} */ @@ -3834,6 +3670,7 @@ return Result._MAP.GENERIC_ERROR; } /** + * RPC is included in a functional group explicitly blocked by the user. * @return {String} */ @@ -3842,6 +3679,8 @@ return Result._MAP.USER_DISALLOWED; } /** + * The RPC (e.g. ReadDID) executed successfully but the data exceeded the platform maximum threshold and thus, + * only part of the data is available. * @return {String} */ @@ -3850,6 +3689,7 @@ return Result._MAP.TRUNCATED_DATA; } /** + * Sync doesn't support the protocol that is requested by the mobile application * @return {String} */ @@ -3858,6 +3698,7 @@ return Result._MAP.UNSUPPORTED_VERSION; } /** + * The user has turned off access to vehicle data, and it is globally unavailable to mobile applications. * @return {String} */ @@ -3866,6 +3707,7 @@ return Result._MAP.VEHICLE_DATA_NOT_ALLOWED; } /** + * A specified file could not be found on the headunit. * @return {String} */ @@ -3874,6 +3716,7 @@ return Result._MAP.FILE_NOT_FOUND; } /** + * User selected to Cancel Route. * @return {String} */ @@ -3882,6 +3725,7 @@ return Result._MAP.CANCEL_ROUTE; } /** + * The RPC (e.g. Slider) executed successfully and the user elected to save the current position / value. * @return {String} */ @@ -3890,6 +3734,7 @@ return Result._MAP.SAVED; } /** + * The certificate provided during authentication is invalid. * @return {String} */ @@ -3898,6 +3743,7 @@ return Result._MAP.INVALID_CERT; } /** + * The certificate provided during authentication is expired. * @return {String} */ @@ -3906,6 +3752,8 @@ return Result._MAP.EXPIRED_CERT; } /** + * The provided hash ID does not match the hash of the current set of registered data or the core could not resume + * the previous data. * @return {String} */ @@ -3914,6 +3762,8 @@ return Result._MAP.RESUME_FAILED; } /** + * The requested information is currently not available. This is different than UNSUPPORTED_RESOURCE because it + * implies the data is at some point available. * @return {String} */ @@ -3922,6 +3772,7 @@ return Result._MAP.DATA_NOT_AVAILABLE; } /** + * The value being set is read only * @return {String} */ @@ -3930,6 +3781,7 @@ return Result._MAP.READ_ONLY; } /** + * The data sent failed to pass CRC check in receiver end * @return {String} */ @@ -3938,20 +3790,29 @@ return Result._MAP.CORRUPTED_DATA; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * SDL receives an un-encrypted RPC request that needs protection. + * @return {String} + */ + + + static get ENCRYPTION_NEEDED() { + return Result._MAP.ENCRYPTION_NEEDED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { return Result._valueForKey(key, Result._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { @@ -3996,7 +3857,8 @@ 'RESUME_FAILED': 'RESUME_FAILED', 'DATA_NOT_AVAILABLE': 'DATA_NOT_AVAILABLE', 'READ_ONLY': 'READ_ONLY', - 'CORRUPTED_DATA': 'CORRUPTED_DATA' + 'CORRUPTED_DATA': 'CORRUPTED_DATA', + 'ENCRYPTION_NEEDED': 'ENCRYPTION_NEEDED' }); /* @@ -17804,539 +17666,342 @@ } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} ImageType - * @property {Object} _MAP + * Contains information about a SoftButton's capabilities. */ - class ImageType extends Enum { + class SoftButtonCapabilities extends RpcStruct { /** - * @constructor - */ - constructor() { - super(); + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @return {String} + * @param {Boolean} available - The button supports a short press. Whenever the button is pressed short, + * onButtonPressed( SHORT) will be invoked. + * @return {SoftButtonCapabilities} */ - static get STATIC() { - return ImageType._MAP.STATIC; + setShortPressAvailable(available) { + this.setParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, available); + return this; } /** - * @return {String} + * @return {Boolean} */ - static get DYNAMIC() { - return ImageType._MAP.DYNAMIC; + getShortPressAvailable() { + return this.getParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @param {Boolean} available - The button supports a LONG press. Whenever the button is pressed long, + * onButtonPressed( LONG) will be invoked. + * @return {SoftButtonCapabilities} + */ - static valueForKey(key) { - return ImageType._valueForKey(key, ImageType._MAP); + setLongPressAvailable(available) { + this.setParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, available); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ - - - static keyForValue(value) { - return ImageType._keyForValue(value, ImageType._MAP); - } - - } - - ImageType._MAP = Object.freeze({ - 'STATIC': 'STATIC', - 'DYNAMIC': 'DYNAMIC' - }); + * @return {Boolean} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class Image extends RpcStruct { - /** - * @constructor - */ - constructor(parameters) { - super(parameters); + getLongPressAvailable() { + return this.getParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE); } /** - * @param {String} value - * @return {Image} - */ + * @param {Boolean} available - The button supports "button down" and "button up". Whenever the button is pressed, + * onButtonEvent( DOWN) will be invoked. Whenever the button is released, + * onButtonEvent( UP) will be invoked. + * @return {SoftButtonCapabilities} + */ - setValue(value) { - this.setParameter(Image.KEY_VALUE, value); + setUpDownAvailable(available) { + this.setParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE, available); return this; } /** - * @return {String} - */ + * @return {Boolean} + */ - getValue() { - return this.getParameter(Image.KEY_VALUE); + getUpDownAvailable() { + return this.getParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE); } /** - * @param {ImageType} type - * @return {Image} - */ + * @param {Boolean} supported - The button supports referencing a static or dynamic image. + * @return {SoftButtonCapabilities} + */ - setImageType(type) { - this.validateType(ImageType, type); - this.setParameter(Image.KEY_IMAGE_TYPE, type); + setImageSupported(supported) { + this.setParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED, supported); return this; } /** - * @return {ImageType} - */ + * @return {Boolean} + */ - getImageType() { - return this.getObject(ImageType, Image.KEY_IMAGE_TYPE); + getImageSupported() { + return this.getParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED); } /** - * @param {Boolean} isTemplate - * @return {Image} - */ + * @param {Boolean} supported - The button supports the use of text. If not included, the default value should be + * considered true that the button will support text. + * @return {SoftButtonCapabilities} + */ - setIsTemplate(isTemplate) { - this.setParameter(Image.KEY_IS_TEMPLATE, isTemplate); + setTextSupported(supported) { + this.setParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED, supported); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ - getIsTemplate() { - return this.getParameter(Image.KEY_IS_TEMPLATE); + getTextSupported() { + return this.getParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED); } } - Image.KEY_VALUE = 'value'; - Image.KEY_IMAGE_TYPE = 'imageType'; - Image.KEY_IS_TEMPLATE = 'isTemplate'; + SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable'; + SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable'; + SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable'; + SoftButtonCapabilities.KEY_IMAGE_SUPPORTED = 'imageSupported'; + SoftButtonCapabilities.KEY_TEXT_SUPPORTED = 'textSupported'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Contains a list of prerecorded speech items present on the platform. + * @typedef {Enum} PrerecordedSpeech + * @property {Object} _MAP + */ - class MenuParams extends RpcStruct { + class PrerecordedSpeech extends Enum { /** - * @constructor - */ - constructor(parameters) { - super(parameters); + * @constructor + */ + constructor() { + super(); } /** - * @param {Number} id - * @return {MenuParams} - */ + * @return {String} + */ - setParentID(id) { - this.setParameter(MenuParams.KEY_PARENT_ID, id); - return this; + static get HELP_JINGLE() { + return PrerecordedSpeech._MAP.HELP_JINGLE; } /** - * @return {Number} - */ + * @return {String} + */ - getParentID() { - return this.getParameter(MenuParams.KEY_PARENT_ID); + static get INITIAL_JINGLE() { + return PrerecordedSpeech._MAP.INITIAL_JINGLE; } /** - * @param {Number} position - * @return {MenuParams} - */ + * @return {String} + */ - setPosition(position) { - this.setParameter(MenuParams.KEY_POSITION, position); - return this; + static get LISTEN_JINGLE() { + return PrerecordedSpeech._MAP.LISTEN_JINGLE; } /** - * @return {Number} - */ + * @return {String} + */ - getPosition() { - return this.getParameter(MenuParams.KEY_POSITION); + static get POSITIVE_JINGLE() { + return PrerecordedSpeech._MAP.POSITIVE_JINGLE; } /** - * @param {String} menuName - * @return {MenuParams} - */ + * @return {String} + */ - setMenuName(menuName) { - this.setParameter(MenuParams.KEY_MENU_NAME, menuName); - return this; + static get NEGATIVE_JINGLE() { + return PrerecordedSpeech._MAP.NEGATIVE_JINGLE; } /** - * @param {String} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - getMenuName() { - return this.getParameter(MenuParams.KEY_MENU_NAME); + static valueForKey(key) { + return PrerecordedSpeech._valueForKey(key, PrerecordedSpeech._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PrerecordedSpeech._keyForValue(value, PrerecordedSpeech._MAP); } } - MenuParams.KEY_PARENT_ID = 'parentID'; - MenuParams.KEY_POSITION = 'position'; - MenuParams.KEY_MENU_NAME = 'menuName'; + PrerecordedSpeech._MAP = Object.freeze({ + 'HELP_JINGLE': 'HELP_JINGLE', + 'INITIAL_JINGLE': 'INITIAL_JINGLE', + 'LISTEN_JINGLE': 'LISTEN_JINGLE', + 'POSITIVE_JINGLE': 'POSITIVE_JINGLE', + 'NEGATIVE_JINGLE': 'NEGATIVE_JINGLE' + }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Contains information about on-screen preset capabilities. + */ - class AddCommand extends RpcRequest { + class PresetBankCapabilities extends RpcStruct { /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.AddCommand); + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @param {Number} id - * @return {AddCommand} - */ + * @param {Boolean} available - Onscreen custom presets are available. + * @return {PresetBankCapabilities} + */ - setCmdID(id) { - this.setParameter(AddCommand.KEY_CMD_ID, id); + setOnScreenPresetsAvailable(available) { + this.setParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE, available); return this; } /** - * @return {Number} - */ + * @return {Boolean} + */ - getCmdID() { - return this.getParameter(AddCommand.KEY_CMD_ID); + getOnScreenPresetsAvailable() { + return this.getParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE); } + + } + + PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE = 'onScreenPresetsAvailable'; + + /* eslint-disable camelcase */ + + class VehicleType extends RpcStruct { /** - * @param {MenuParams} menuParams - * @return {AddCommand} - */ + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} make - Make of the vehicle, e.g. Ford + * @return {VehicleType} + */ - setMenuParams(menuParams) { - this.validateType(MenuParams, menuParams); - this.setParameter(AddCommand.KEY_MENU_PARAMS, menuParams); + setMake(make) { + this.setParameter(VehicleType.KEY_MAKE, make); return this; } /** - * @return {MenuParams} - */ + * @return {String} + */ - getMenuParams() { - return this.getObject(MenuParams, AddCommand.KEY_MENU_PARAMS); + getMake() { + return this.getParameter(VehicleType.KEY_MAKE); } /** - * @param {Array} vrCommands - * @return {AddCommand} - */ + * @param {String} model - Model of the vehicle, e.g. Fiesta + * @return {VehicleType} + */ - setVrCommands(vrCommands) { - this.setParameter(AddCommand.KEY_VR_COMMANDS, vrCommands); + setModel(model) { + this.setParameter(VehicleType.KEY_MODEL, model); return this; } /** - * @return {Array} - */ + * @return {String} + */ - getVrCommands() { - return this.getParameter(AddCommand.KEY_VR_COMMANDS); + getModel() { + return this.getParameter(VehicleType.KEY_MODEL); } /** - * @param {Image} icon - * @return {AddCommand} - */ + * @param {String} year - Model Year of the vehicle, e.g. 2013 + * @return {VehicleType} + */ - setCmdIcon(icon) { - this.validateType(Image, icon); - this.setParameter(AddCommand.KEY_CMD_ICON, icon); + setModelYear(year) { + this.setParameter(VehicleType.KEY_MODEL_YEAR, year); return this; } /** - * @return {Image} - */ + * @return {String} + */ - getCmdIcon() { - return this.getObject(Image, AddCommand.KEY_CMD_ICON); + getModelYear() { + return this.getParameter(VehicleType.KEY_MODEL_YEAR); } + /** + * @param {String} trim - Trim of the vehicle, e.g. SE + * @return {VehicleType} + */ - } - - AddCommand.KEY_CMD_ICON = 'cmdIcon'; - AddCommand.KEY_MENU_PARAMS = 'menuParams'; - AddCommand.KEY_CMD_ID = 'cmdID'; - AddCommand.KEY_VR_COMMANDS = 'vrCommands'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class AddCommandResponse extends RpcResponse { - /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.AddCommand); + setTrim(trim) { + this.setParameter(VehicleType.KEY_TRIM, trim); + return this; } + /** + * @return {String} + */ - } - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class RpcNotification extends RpcMessage { - /** - * @constructor - */ - constructor(store) { - super(store); - this.setRPCType(RpcType.NOTIFICATION); + getTrim() { + return this.getParameter(VehicleType.KEY_TRIM); } } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + VehicleType.KEY_MAKE = 'make'; + VehicleType.KEY_MODEL = 'model'; + VehicleType.KEY_MODEL_YEAR = 'modelYear'; + VehicleType.KEY_TRIM = 'trim'; + + /* eslint-disable camelcase */ /** - * @typedef {Enum} HMILevel + * Contains information about the HMI zone capabilities. For future use. + * @typedef {Enum} HmiZoneCapabilities * @property {Object} _MAP */ - class HMILevel extends Enum { + class HmiZoneCapabilities extends Enum { + /** + * @constructor + */ constructor() { super(); } @@ -18345,665 +18010,584 @@ */ - static get HMI_FULL() { - return HMILevel._MAP.HMI_FULL; + static get FRONT() { + return HmiZoneCapabilities._MAP.FRONT; } /** * @return {String} */ - static get HMI_LIMITED() { - return HMILevel._MAP.HMI_LIMITED; - } - /** - * @return {String} - */ - - - static get HMI_BACKGROUND() { - return HMILevel._MAP.HMI_BACKGROUND; + static get BACK() { + return HmiZoneCapabilities._MAP.BACK; } /** - * @return {String} + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found */ - static get HMI_NONE() { - return HMILevel._MAP.HMI_NONE; - } - /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ - - static valueForKey(key) { - return HMILevel._valueForKey(key, HMILevel._MAP); + return HmiZoneCapabilities._valueForKey(key, HmiZoneCapabilities._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return HMILevel._keyForValue(value, HMILevel._MAP); + return HmiZoneCapabilities._keyForValue(value, HmiZoneCapabilities._MAP); } } - HMILevel._MAP = Object.freeze({ - 'HMI_FULL': 'FULL', - 'HMI_LIMITED': 'LIMITED', - 'HMI_BACKGROUND': 'BACKGROUND', - 'HMI_NONE': 'NONE' + HmiZoneCapabilities._MAP = Object.freeze({ + 'FRONT': 'FRONT', + 'BACK': 'BACK' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} AudioStreamingState + * @typedef {Enum} MediaClockFormat * @property {Object} _MAP */ - class AudioStreamingState extends Enum { + class MediaClockFormat extends Enum { + /** + * @constructor + */ constructor() { super(); } /** + * minutesFieldWidth = 2;minutesFieldMax = 19;secondsFieldWidth = 2;secondsFieldMax = 99;maxHours = 19;maxMinutes + * = 59;maxSeconds = 59; used for Type II and CID headunits * @return {String} */ - static get AUDIBLE() { - return AudioStreamingState._MAP.AUDIBLE; + static get CLOCK1() { + return MediaClockFormat._MAP.CLOCK1; } /** + * minutesFieldWidth = 3;minutesFieldMax = 199;secondsFieldWidth = 2;secondsFieldMax = 99;maxHours = 59;maxMinutes + * = 59;maxSeconds = 59; used for Type V headunit * @return {String} */ - static get ATTENUATED() { - return AudioStreamingState._MAP.ATTENUATED; + static get CLOCK2() { + return MediaClockFormat._MAP.CLOCK2; } /** + * minutesFieldWidth = 2;minutesFieldMax = 59;secondsFieldWidth = 2;secondsFieldMax = 59;maxHours = 9;maxMinutes = + * 59;maxSeconds = 59; used for GEN1.1 MFD3/4/5 headunits * @return {String} */ - static get NOT_AUDIBLE() { - return AudioStreamingState._MAP.NOT_AUDIBLE; + static get CLOCK3() { + return MediaClockFormat._MAP.CLOCK3; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * 5 characters possible Format: 1|sp c :|sp c c 1|sp : digit "1" or space c : character out of following + * character set: sp|0-9|[letters, see TypeII column in XLS. See :|sp : colon or space used for Type II headunit + * @return {String} + */ - static valueForKey(key) { - return AudioStreamingState._valueForKey(key, AudioStreamingState._MAP); + static get CLOCKTEXT1() { + return MediaClockFormat._MAP.CLOCKTEXT1; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ - - - static keyForValue(value) { - return AudioStreamingState._keyForValue(value, AudioStreamingState._MAP); - } - - } - - AudioStreamingState._MAP = Object.freeze({ - 'AUDIBLE': 'AUDIBLE', - 'ATTENUATED': 'ATTENUATED', - 'NOT_AUDIBLE': 'NOT_AUDIBLE' - }); + * 5 chars possible Format: 1|sp c :|sp c c 1|sp : digit "1" or space c : character out of following character + * set: sp|0-9|[letters, see CID column in XLS. See :|sp : colon or space used for CID headunit NOTE: difference + * between CLOCKTEXT1 and CLOCKTEXT2 is the supported character set + * @return {String} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} VideoStreamingState - * @property {Object} _MAP - */ - class VideoStreamingState extends Enum { - constructor() { - super(); + static get CLOCKTEXT2() { + return MediaClockFormat._MAP.CLOCKTEXT2; } /** + * 6 chars possible Format: 1|sp c c :|sp c c 1|sp : digit "1" or space c : character out of following character + * set: sp|0-9|[letters, see Type 5 column in XLS]. See :|sp : colon or space used for Type V headunit * @return {String} */ - static get STREAMABLE() { - return VideoStreamingState._MAP.STREAMABLE; + static get CLOCKTEXT3() { + return MediaClockFormat._MAP.CLOCKTEXT3; } /** + * 6 chars possible Format: c :|sp c c : c c :|sp : colon or space c : character out of following character set: + * sp|0-9|[letters]. used for GEN1.1 MFD3/4/5 headunits * @return {String} */ - static get NOT_STREAMABLE() { - return VideoStreamingState._MAP.NOT_STREAMABLE; + static get CLOCKTEXT4() { + return MediaClockFormat._MAP.CLOCKTEXT4; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { - return VideoStreamingState._valueForKey(key, VideoStreamingState._MAP); + return MediaClockFormat._valueForKey(key, MediaClockFormat._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return VideoStreamingState._keyForValue(value, VideoStreamingState._MAP); + return MediaClockFormat._keyForValue(value, MediaClockFormat._MAP); } } - VideoStreamingState._MAP = Object.freeze({ - 'STREAMABLE': 'STREAMABLE', - 'NOT_STREAMABLE': 'NOT_STREAMABLE' + MediaClockFormat._MAP = Object.freeze({ + 'CLOCK1': 'CLOCK1', + 'CLOCK2': 'CLOCK2', + 'CLOCK3': 'CLOCK3', + 'CLOCKTEXT1': 'CLOCKTEXT1', + 'CLOCKTEXT2': 'CLOCKTEXT2', + 'CLOCKTEXT3': 'CLOCKTEXT3', + 'CLOCKTEXT4': 'CLOCKTEXT4' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} SystemContext - * @property {Object} _MAP - */ + /* eslint-disable camelcase */ - class SystemContext extends Enum { - constructor() { - super(); - } + class ImageResolution extends RpcStruct { /** - * @return {String} + * @constructor */ - - - static get SYSCTXT_MAIN() { - return SystemContext._MAP.SYSCTXT_MAIN; + constructor(parameters) { + super(parameters); } /** - * @return {String} + * @param {Number} width - The image resolution width. + * @return {ImageResolution} */ - static get SYSCTXT_VRSESSION() { - return SystemContext._MAP.SYSCTXT_VRSESSION; + setResolutionWidth(width) { + this.setParameter(ImageResolution.KEY_RESOLUTION_WIDTH, width); + return this; } /** - * @return {String} + * @return {Number} */ - static get SYSCTXT_MENU() { - return SystemContext._MAP.SYSCTXT_MENU; + getResolutionWidth() { + return this.getParameter(ImageResolution.KEY_RESOLUTION_WIDTH); } /** - * @return {String} + * @param {Number} height - The image resolution height. + * @return {ImageResolution} */ - static get SYSCTXT_HMI_OBSCURED() { - return SystemContext._MAP.SYSCTXT_HMI_OBSCURED; + setResolutionHeight(height) { + this.setParameter(ImageResolution.KEY_RESOLUTION_HEIGHT, height); + return this; } /** - * @return {String} + * @return {Number} */ - static get SYSCTXT_ALERT() { - return SystemContext._MAP.SYSCTXT_ALERT; - } - /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ - - - static valueForKey(key) { - return SystemContext._valueForKey(key, SystemContext._MAP); - } - /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ - - - static keyForValue(value) { - return SystemContext._keyForValue(value, SystemContext._MAP); + getResolutionHeight() { + return this.getParameter(ImageResolution.KEY_RESOLUTION_HEIGHT); } } - SystemContext._MAP = Object.freeze({ - 'SYSCTXT_MAIN': 'MAIN', - 'SYSCTXT_VRSESSION': 'VRSESSION', - 'SYSCTXT_MENU': 'MENU', - 'SYSCTXT_HMI_OBSCURED': 'HMI_OBSCURED', - 'SYSCTXT_ALERT': 'ALERT' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - class OnHmiStatus extends RpcNotification { - /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.OnHMIStatus); - } - /** - * @param {HMILevel} hmiLevel - * @return {OnHmiStatus} - */ - - - setHMILevel(hmiLevel) { - this.validateType(HMILevel, hmiLevel); - this.setParameter(OnHmiStatus.KEY_HMI_LEVEL, hmiLevel); - return this; - } - /** - * @return {HMILevel} - */ - - - getHMILevel() { - return this.getObject(HMILevel, OnHmiStatus.KEY_HMI_LEVEL); - } - /** - * @param {AudioStreamingState} audioStreamingState - * @return {OnHmiStatus} - */ + ImageResolution.KEY_RESOLUTION_WIDTH = 'resolutionWidth'; + ImageResolution.KEY_RESOLUTION_HEIGHT = 'resolutionHeight'; + /* eslint-disable camelcase */ - setAudioStreamingState(audioStreamingState) { - this.validateType(AudioStreamingState, audioStreamingState); - this.setParameter(OnHmiStatus.KEY_AUDIO_STREAMING_STATE, audioStreamingState); - return this; - } + class TouchEventCapabilities extends RpcStruct { /** - * @return {AudioStreamingState} - */ - - - getAudioStreamingState() { - return this.getObject(AudioStreamingState, OnHmiStatus.KEY_AUDIO_STREAMING_STATE); + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @param {SystemContext} systemContext - * @return {OnHmiStatus} - */ + * @param {Boolean} available + * @return {TouchEventCapabilities} + */ - setSystemContext(systemContext) { - this.validateType(SystemContext, systemContext); - this.setParameter(OnHmiStatus.KEY_SYSTEM_CONTEXT, systemContext); + setPressAvailable(available) { + this.setParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE, available); return this; } /** - * @return {SystemContext} - */ + * @return {Boolean} + */ - getSystemContext() { - return this.getObject(SystemContext, OnHmiStatus.KEY_SYSTEM_CONTEXT); + getPressAvailable() { + return this.getParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE); } /** - * @param {VideoStreamingState} videoStreamingState - * @return {OnHmiStatus} - */ + * @param {Boolean} available + * @return {TouchEventCapabilities} + */ - setVideoStreamingState(videoStreamingState) { - this.validateType(VideoStreamingState, videoStreamingState); - this.setParameter(OnHmiStatus.KEY_VIDEO_STREAMING_STATE, videoStreamingState); + setMultiTouchAvailable(available) { + this.setParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE, available); return this; } /** - * @return {VideoStreamingState} - */ + * @return {Boolean} + */ - getVideoStreamingState() { - return this.getObject(VideoStreamingState, OnHmiStatus.KEY_VIDEO_STREAMING_STATE); + getMultiTouchAvailable() { + return this.getParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE); } /** - * @param {Number} windowID - * @return {Show} - */ + * @param {Boolean} available + * @return {TouchEventCapabilities} + */ - setWindowID(windowID) { - this.setParameter(OnHmiStatus.KEY_WINDOW_ID, windowID); + setDoublePressAvailable(available) { + this.setParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE, available); return this; } /** - * @return {Number} - */ + * @return {Boolean} + */ - getWindowID() { - return this.getParameter(OnHmiStatus.KEY_WINDOW_ID); + getDoublePressAvailable() { + return this.getParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE); } } - OnHmiStatus.KEY_HMI_LEVEL = 'hmiLevel'; - OnHmiStatus.KEY_AUDIO_STREAMING_STATE = 'audioStreamingState'; - OnHmiStatus.KEY_SYSTEM_CONTEXT = 'systemContext'; - OnHmiStatus.KEY_VIDEO_STREAMING_STATE = 'videoStreamingState'; - OnHmiStatus.KEY_WINDOW_ID = 'windowID'; + TouchEventCapabilities.KEY_PRESS_AVAILABLE = 'pressAvailable'; + TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE = 'multiTouchAvailable'; + TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE = 'doublePressAvailable'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ - class OnLanguageChange extends RpcNotification { + class ScreenParams extends RpcStruct { /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.OnLanguageChange); + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @param {Language} language - * @return {OnLanguageChange} - */ + * @param {ImageResolution} resolution - The resolution of the prescribed screen area. + * @return {ScreenParams} + */ - setLanguage(language) { - this.validateType(Language, language); - this.setParameter(OnLanguageChange.KEY_LANGUAGE, language); + setResolution(resolution) { + this.validateType(ImageResolution, resolution); + this.setParameter(ScreenParams.KEY_RESOLUTION, resolution); return this; } /** - * @return {Language} - */ + * @return {ImageResolution} + */ - getLanguage() { - return this.getObject(Language, OnLanguageChange.KEY_LANGUAGE); + getResolution() { + return this.getObject(ImageResolution, ScreenParams.KEY_RESOLUTION); } /** - * @param {Language} language - * @return {OnLanguageChange} - */ + * @param {TouchEventCapabilities} available - Types of screen touch events available in screen area. + * @return {ScreenParams} + */ - setHMIDisplayLanguage(language) { - this.validateType(Language, language); - this.setParameter(OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE, language); + setTouchEventAvailable(available) { + this.validateType(TouchEventCapabilities, available); + this.setParameter(ScreenParams.KEY_TOUCH_EVENT_AVAILABLE, available); return this; } /** - * @return {Language} - */ + * @return {TouchEventCapabilities} + */ - getHMIDisplayLanguage() { - return this.getObject(Language, OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE); + getTouchEventAvailable() { + return this.getObject(TouchEventCapabilities, ScreenParams.KEY_TOUCH_EVENT_AVAILABLE); } } - OnLanguageChange.KEY_LANGUAGE = 'language'; - OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; + ScreenParams.KEY_RESOLUTION = 'resolution'; + ScreenParams.KEY_TOUCH_EVENT_AVAILABLE = 'touchEventAvailable'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} FileType + * @typedef {Enum} ImageFieldName * @property {Object} _MAP */ - class FileType extends Enum { + class ImageFieldName extends Enum { + /** + * @constructor + */ constructor() { super(); } /** + * The image field for SoftButton * @return {String} */ - static get GRAPHIC_BMP() { - return FileType._MAP.GRAPHIC_BMP; + static get softButtonImage() { + return ImageFieldName._MAP.softButtonImage; } /** + * The first image field for Choice * @return {String} */ - static get GRAPHIC_JPEG() { - return FileType._MAP.GRAPHIC_JPEG; + static get choiceImage() { + return ImageFieldName._MAP.choiceImage; } /** + * The secondary image field for Choice * @return {String} */ - static get GRAPHIC_PNG() { - return FileType._MAP.GRAPHIC_PNG; + static get choiceSecondaryImage() { + return ImageFieldName._MAP.choiceSecondaryImage; } /** + * The image field for vrHelpItem * @return {String} */ - static get AUDIO_WAVE() { - return FileType._MAP.AUDIO_WAVE; + static get vrHelpItem() { + return ImageFieldName._MAP.vrHelpItem; } /** + * The image field for Turn * @return {String} */ - static get AUDIO_AAC() { - return FileType._MAP.AUDIO_AAC; + static get turnIcon() { + return ImageFieldName._MAP.turnIcon; } /** + * The image field for the menu icon in SetGlobalProperties * @return {String} */ - static get BINARY() { - return FileType._MAP.BINARY; + static get menuIcon() { + return ImageFieldName._MAP.menuIcon; + } + /** + * The image field for AddCommand + * @return {String} + */ + + + static get cmdIcon() { + return ImageFieldName._MAP.cmdIcon; + } + /** + * The image field for the app icon (set by setAppIcon) + * @return {String} + */ + + + static get appIcon() { + return ImageFieldName._MAP.appIcon; + } + /** + * The primary image field for Show + * @return {String} + */ + + + static get graphic() { + return ImageFieldName._MAP.graphic; + } + /** + * The secondary image field for Show + * @return {String} + */ + + + static get secondaryGraphic() { + return ImageFieldName._MAP.secondaryGraphic; + } + /** + * The primary image field for ShowConstantTBT + * @return {String} + */ + + + static get showConstantTBTIcon() { + return ImageFieldName._MAP.showConstantTBTIcon; + } + /** + * The secondary image field for ShowConstantTBT + * @return {String} + */ + + + static get showConstantTBTNextTurnIcon() { + return ImageFieldName._MAP.showConstantTBTNextTurnIcon; + } + /** + * The optional image of a destination / location + * @return {String} + */ + + + static get locationImage() { + return ImageFieldName._MAP.locationImage; + } + /** + * The image field for Alert + * @return {String} + */ + + + static get alertIcon() { + return ImageFieldName._MAP.alertIcon; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ImageFieldName._valueForKey(key, ImageFieldName._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ImageFieldName._keyForValue(value, ImageFieldName._MAP); + } + + } + + ImageFieldName._MAP = Object.freeze({ + 'softButtonImage': 'softButtonImage', + 'choiceImage': 'choiceImage', + 'choiceSecondaryImage': 'choiceSecondaryImage', + 'vrHelpItem': 'vrHelpItem', + 'turnIcon': 'turnIcon', + 'menuIcon': 'menuIcon', + 'cmdIcon': 'cmdIcon', + 'appIcon': 'appIcon', + 'graphic': 'graphic', + 'secondaryGraphic': 'secondaryGraphic', + 'showConstantTBTIcon': 'showConstantTBTIcon', + 'showConstantTBTNextTurnIcon': 'showConstantTBTNextTurnIcon', + 'locationImage': 'locationImage', + 'alertIcon': 'alertIcon' + }); + + /* eslint-disable camelcase */ + /** + * Enumeration listing possible file types. + * @typedef {Enum} FileType + * @property {Object} _MAP + */ + + class FileType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get GRAPHIC_BMP() { + return FileType._MAP.GRAPHIC_BMP; + } + /** + * @return {String} + */ + + + static get GRAPHIC_JPEG() { + return FileType._MAP.GRAPHIC_JPEG; + } + /** + * @return {String} + */ + + + static get GRAPHIC_PNG() { + return FileType._MAP.GRAPHIC_PNG; + } + /** + * @return {String} + */ + + + static get AUDIO_WAVE() { + return FileType._MAP.AUDIO_WAVE; + } + /** + * @return {String} + */ + + + static get AUDIO_MP3() { + return FileType._MAP.AUDIO_MP3; + } + /** + * @return {String} + */ + + + static get AUDIO_AAC() { + return FileType._MAP.AUDIO_AAC; + } + /** + * @return {String} + */ + + + static get BINARY() { + return FileType._MAP.BINARY; } /** * @return {String} @@ -19014,20 +18598,20 @@ return FileType._MAP.JSON; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { return FileType._valueForKey(key, FileType._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { @@ -19047,554 +18631,521 @@ 'JSON': 'JSON' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ - class PutFile extends RpcRequest { + class ImageField extends RpcStruct { /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.PutFile); - } // ------ Not part of the RPC spec itself ----- - + * @constructor + */ + constructor(parameters) { + super(parameters); + } /** - * @param {Uint8Array} fileData - * @return {PutFile} - */ + * @param {ImageFieldName} name - The name that identifies the field. See ImageFieldName. + * @return {ImageField} + */ - setFileData(fileData) { - this.setBulkData(fileData); + setName(name) { + this.validateType(ImageFieldName, name); + this.setParameter(ImageField.KEY_NAME, name); return this; } /** - * @return {Uint8Array} - */ - + * @return {ImageFieldName} + */ - getFileData() { - return this.getBulkData(); - } // ----------------- END ----------------------- + getName() { + return this.getObject(ImageFieldName, ImageField.KEY_NAME); + } /** - * @param {String} fileName - * @return {PutFile} - */ + * @param {FileType[]} supported - The image types that are supported in this field. See FileType. + * @return {ImageField} + */ - setFileName(fileName) { - this.setParameter(PutFile.KEY_FILE_NAME, fileName); + setImageTypeSupported(supported) { + this.validateType(FileType, supported, true); + this.setParameter(ImageField.KEY_IMAGE_TYPE_SUPPORTED, supported); return this; } /** - * @return {String} - */ + * @return {FileType[]} + */ - getFileName() { - return this.getParameter(PutFile.KEY_FILE_NAME); + getImageTypeSupported() { + return this.getObject(FileType, ImageField.KEY_IMAGE_TYPE_SUPPORTED); } /** - * @param {FileType} fileType - * @return {PutFile} - */ + * @param {ImageResolution} resolution - The image resolution of this field. + * @return {ImageField} + */ - setFileType(fileType) { - this.validateType(FileType, fileType); - this.setParameter(PutFile.KEY_FILE_TYPE, fileType); + setImageResolution(resolution) { + this.validateType(ImageResolution, resolution); + this.setParameter(ImageField.KEY_IMAGE_RESOLUTION, resolution); return this; } /** - * @return {FileType} - */ + * @return {ImageResolution} + */ - getFileType() { - return this.getObject(FileType, PutFile.KEY_MENU_PARAMS); + getImageResolution() { + return this.getObject(ImageResolution, ImageField.KEY_IMAGE_RESOLUTION); } - /** - * @param {Boolean} persistentFile - * @return {PutFile} - */ + } - setPersistentFile(persistentFile) { - this.setParameter(PutFile.KEY_PERSISTENT_FILE, persistentFile); - return this; + ImageField.KEY_NAME = 'name'; + ImageField.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported'; + ImageField.KEY_IMAGE_RESOLUTION = 'imageResolution'; + + /* eslint-disable camelcase */ + /** + * See DAES for further infos regarding the displays + * @deprecated + * @typedef {Enum} DisplayType + * @property {Object} _MAP + */ + + class DisplayType extends Enum { + /** + * @deprecated + * @constructor + */ + constructor() { + super(); } /** - * @return {Boolean} - */ + * @deprecated + * @return {String} + */ - getPersistentFile() { - return this.getParameter(PutFile.KEY_PERSISTENT_FILE); + static get CID() { + return DisplayType._MAP.CID; } /** - * @param {Boolean} systemFile - * @return {PutFile} - */ + * @deprecated + * @return {String} + */ - setSystemFile(systemFile) { - this.setParameter(PutFile.KEY_SYSTEM_FILE, systemFile); - return this; + static get TYPE2() { + return DisplayType._MAP.TYPE2; } /** - * @return {Boolean} - */ + * @deprecated + * @return {String} + */ - getSystemFile() { - return this.getParameter(PutFile.KEY_SYSTEM_FILE); + static get TYPE5() { + return DisplayType._MAP.TYPE5; } /** - * @param {Number} offset - * @return {PutFile} - */ + * @deprecated + * @return {String} + */ - setOffset(offset) { - this.setParameter(PutFile.KEY_OFFSET, offset); - return this; + static get NGN() { + return DisplayType._MAP.NGN; } /** - * @return {Number} - */ + * @deprecated + * @return {String} + */ - getOffset() { - return this.getParameter(PutFile.KEY_OFFSET); + static get GEN2_8_DMA() { + return DisplayType._MAP.GEN2_8_DMA; } /** - * @param {Number} length - * @return {PutFile} - */ + * @deprecated + * @return {String} + */ - setLength(length) { - this.setParameter(PutFile.KEY_LENGTH, length); - return this; + static get GEN2_6_DMA() { + return DisplayType._MAP.GEN2_6_DMA; } /** - * @return {Number} - */ + * @deprecated + * @return {String} + */ - getLength() { - return this.getParameter(PutFile.KEY_LENGTH); + static get MFD3() { + return DisplayType._MAP.MFD3; } /** - * @param {Number} crc - * @return {PutFile} - */ + * @deprecated + * @return {String} + */ - setCRC(crc) { - this.setParameter(PutFile.KEY_CRC, crc); - return this; + static get MFD4() { + return DisplayType._MAP.MFD4; } /** - * @return {Number} - */ + * @deprecated + * @return {String} + */ - getCRC() { - return this.getParameter(PutFile.KEY_CRC); + static get MFD5() { + return DisplayType._MAP.MFD5; } + /** + * @deprecated + * @return {String} + */ - } - PutFile.KEY_FILE_NAME = 'syncFileName'; - PutFile.KEY_FILE_TYPE = 'fileType'; - PutFile.KEY_PERSISTENT_FILE = 'persistentFile'; - PutFile.KEY_SYSTEM_FILE = 'systemFile'; - PutFile.KEY_OFFSET = 'offset'; - PutFile.KEY_LENGTH = 'length'; - PutFile.KEY_CRC = 'crc'; + static get GEN3_8_INCH() { + return DisplayType._MAP.GEN3_8_INCH; + } + /** + * @deprecated + * @return {String} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class PutFileResponse extends RpcResponse { - /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.PutFile); + static get SDL_GENERIC() { + return DisplayType._MAP.SDL_GENERIC; } /** - * @param {Number} spaceAvailable - * @return {PutFileResponse} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - setSpaceAvailable(spaceAvailable) { - this.setParameter(PutFileResponse.KEY_SPACE_AVAILABLE, spaceAvailable); - return this; + static valueForKey(key) { + return DisplayType._valueForKey(key, DisplayType._MAP); } /** - * @return {Number} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - getSpaceAvailable() { - return this.getParameter(PutFileResponse.KEY_SPACE_AVAILABLE); + static keyForValue(value) { + return DisplayType._keyForValue(value, DisplayType._MAP); } } - PutFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable'; + DisplayType._MAP = Object.freeze({ + 'CID': 'CID', + 'TYPE2': 'TYPE2', + 'TYPE5': 'TYPE5', + 'NGN': 'NGN', + 'GEN2_8_DMA': 'GEN2_8_DMA', + 'GEN2_6_DMA': 'GEN2_6_DMA', + 'MFD3': 'MFD3', + 'MFD4': 'MFD4', + 'MFD5': 'MFD5', + 'GEN3_8_INCH': 'GEN3_8-INCH', + 'SDL_GENERIC': 'SDL_GENERIC' + }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** * @typedef {Enum} TextFieldName * @property {Object} _MAP */ class TextFieldName extends Enum { + /** + * @constructor + */ constructor() { super(); } /** - * @return {String} - */ + * The first line of first set of main fields of the persistent display; applies to "Show" + * @return {String} + */ static get mainField1() { return TextFieldName._MAP.mainField1; } /** - * @return {String} - */ + * The second line of first set of main fields of the persistent display; applies to "Show" + * @return {String} + */ static get mainField2() { return TextFieldName._MAP.mainField2; } /** - * @return {String} - */ + * The first line of second set of main fields of persistent display; applies to "Show" + * @return {String} + */ static get mainField3() { return TextFieldName._MAP.mainField3; } /** - * @return {String} - */ + * The second line of second set of main fields of the persistent display; applies to "Show" + * @return {String} + */ static get mainField4() { return TextFieldName._MAP.mainField4; } /** - * @return {String} - */ + * The status bar on NGN; applies to "Show" + * @return {String} + */ static get statusBar() { return TextFieldName._MAP.statusBar; } /** - * @return {String} - */ + * Text value for MediaClock field; applies to "Show" + * @return {String} + */ static get mediaClock() { return TextFieldName._MAP.mediaClock; } /** - * @return {String} - */ + * The track field of NGN and GEN1.1 MFD displays. This field is only available for media applications; applies to + * "Show" + * @return {String} + */ static get mediaTrack() { return TextFieldName._MAP.mediaTrack; } /** - * @return {String} - */ + * The title of the new template that will be displayed; applies to "Show" + * @return {String} + */ static get templateTitle() { return TextFieldName._MAP.templateTitle; } /** - * @return {String} - */ + * The first line of the alert text field; applies to "Alert" + * @return {String} + */ static get alertText1() { return TextFieldName._MAP.alertText1; } /** - * @return {String} - */ + * The second line of the alert text field; applies to "Alert" + * @return {String} + */ static get alertText2() { return TextFieldName._MAP.alertText2; } /** - * @return {String} - */ + * The third line of the alert text field; applies to "Alert" + * @return {String} + */ static get alertText3() { return TextFieldName._MAP.alertText3; } /** - * @return {String} - */ + * Long form body of text that can include newlines and tabs; applies to "ScrollableMessage" + * @return {String} + */ static get scrollableMessageBody() { return TextFieldName._MAP.scrollableMessageBody; } /** - * @return {String} - */ + * First line suggestion for a user response (in the case of VR enabled interaction) + * @return {String} + */ static get initialInteractionText() { return TextFieldName._MAP.initialInteractionText; } /** - * @return {String} - */ + * First line of navigation text + * @return {String} + */ static get navigationText1() { return TextFieldName._MAP.navigationText1; } /** - * @return {String} - */ + * Second line of navigation text + * @return {String} + */ static get navigationText2() { return TextFieldName._MAP.navigationText2; } /** - * @return {String} - */ + * Estimated Time of Arrival time for navigation + * @return {String} + */ static get ETA() { return TextFieldName._MAP.ETA; } /** - * @return {String} - */ + * Total distance to destination for navigation + * @return {String} + */ static get totalDistance() { return TextFieldName._MAP.totalDistance; } /** - * @return {String} - */ + * First line of text for audio pass thru + * @return {String} + */ static get audioPassThruDisplayText1() { return TextFieldName._MAP.audioPassThruDisplayText1; } /** - * @return {String} - */ + * Second line of text for audio pass thru + * @return {String} + */ static get audioPassThruDisplayText2() { return TextFieldName._MAP.audioPassThruDisplayText2; } /** - * @return {String} - */ + * Header text for slider + * @return {String} + */ static get sliderHeader() { return TextFieldName._MAP.sliderHeader; } /** - * @return {String} - */ + * Footer text for slider + * @return {String} + */ static get sliderFooter() { return TextFieldName._MAP.sliderFooter; } /** - * @return {String} - */ + * Primary text for Choice + * @return {String} + */ static get menuName() { return TextFieldName._MAP.menuName; } /** - * @return {String} - */ + * Secondary text for Choice + * @return {String} + */ static get secondaryText() { return TextFieldName._MAP.secondaryText; } /** - * @return {String} - */ + * Tertiary text for Choice + * @return {String} + */ static get tertiaryText() { return TextFieldName._MAP.tertiaryText; } /** - * @return {String} - */ + * Optional text to label an app menu button (for certain touchscreen platforms). + * @return {String} + */ static get menuTitle() { return TextFieldName._MAP.menuTitle; } /** - * @return {String} - */ + * Optional name / title of intended location for SendLocation. + * @return {String} + */ static get locationName() { return TextFieldName._MAP.locationName; } /** - * @return {String} - */ + * Optional description of intended location / establishment (if applicable) for SendLocation. + * @return {String} + */ static get locationDescription() { return TextFieldName._MAP.locationDescription; } /** - * @return {String} - */ + * Optional location address (if applicable) for SendLocation. + * @return {String} + */ static get addressLines() { return TextFieldName._MAP.addressLines; } /** - * @return {String} - */ + * Optional hone number of intended location / establishment (if applicable) for SendLocation. + * @return {String} + */ static get phoneNumber() { return TextFieldName._MAP.phoneNumber; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { return TextFieldName._valueForKey(key, TextFieldName._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { @@ -19635,93 +19186,71 @@ 'phoneNumber': 'phoneNumber' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** + * The list of potential character sets * @typedef {Enum} CharacterSet * @property {Object} _MAP */ class CharacterSet extends Enum { + /** + * @constructor + */ constructor() { super(); } /** - * @return {String} - */ + * See + * @return {String} + */ static get TYPE2SET() { return CharacterSet._MAP.TYPE2SET; } /** - * @return {String} - */ + * See + * @return {String} + */ static get TYPE5SET() { return CharacterSet._MAP.TYPE5SET; } /** - * @return {String} - */ + * See + * @return {String} + */ static get CID1SET() { return CharacterSet._MAP.CID1SET; } /** - * @return {String} - */ + * See + * @return {String} + */ static get CID2SET() { return CharacterSet._MAP.CID2SET; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { return CharacterSet._valueForKey(key, CharacterSet._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { @@ -19737,84 +19266,57 @@ 'CID2SET': 'CID2SET' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ class TextField extends RpcStruct { + /** + * @constructor + */ constructor(parameters) { super(parameters); } /** - * @param {TextFieldName} textFieldName - * @return {TextField} - */ + * @param {TextFieldName} name - The name that identifies the field. See TextFieldName. + * @return {TextField} + */ - setTextFieldName(textFieldName) { - this.validateType(TextFieldName, textFieldName); - this.setParameter(TextField.KEY_NAME, textFieldName); + setName(name) { + this.validateType(TextFieldName, name); + this.setParameter(TextField.KEY_NAME, name); return this; } /** - * @return {TextFieldName} - */ + * @return {TextFieldName} + */ - getTextFieldName() { + getName() { return this.getObject(TextFieldName, TextField.KEY_NAME); } /** - * @param {CharacterSet} textFieldName - * @return {TextField} - */ + * @param {CharacterSet} set - The character set that is supported in this field. See CharacterSet. + * @return {TextField} + */ - setCharacterSet(characterSet) { - this.validateType(CharacterSet, characterSet); - this.setParameter(TextField.KEY_CHARACTER_SET, characterSet); + setCharacterSet(set) { + this.validateType(CharacterSet, set); + this.setParameter(TextField.KEY_CHARACTER_SET, set); return this; } /** - * @return {CharacterSet} - */ + * @return {CharacterSet} + */ getCharacterSet() { return this.getObject(CharacterSet, TextField.KEY_CHARACTER_SET); } /** - * @param {Number} width - * @return {TextField} - */ + * @param {Number} width - The number of characters in one row of this field. + * @return {TextField} + */ setWidth(width) { @@ -19822,17 +19324,17 @@ return this; } /** - * @return {Number} - */ + * @return {Number} + */ getWidth() { return this.getParameter(TextField.KEY_WIDTH); } /** - * @param {Number} rows - * @return {TextField} - */ + * @param {Number} rows - The number of rows of this field. + * @return {TextField} + */ setRows(rows) { @@ -19840,8 +19342,8 @@ return this; } /** - * @return {Number} - */ + * @return {Number} + */ getRows() { @@ -19855,756 +19357,548 @@ TextField.KEY_WIDTH = 'width'; TextField.KEY_ROWS = 'rows'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Contains information about the display capabilities. This struct is deprecated; please see the new SystemCapability + * DISPLAYS and corresponding struct DisplayCapability + * @deprecated + */ - class ImageResolution extends RpcStruct { + class DisplayCapabilities extends RpcStruct { + /** + * @deprecated + * @constructor + */ constructor(parameters) { super(parameters); } /** - * @param {Number} resolutionWidth - * @return {ImageResolution} - */ + * @deprecated + * @param {DisplayType} type - The type of the display. See DisplayType + * @return {DisplayCapabilities} + */ - setResolutionWidth(resolutionWidth) { - this.setParameter(ImageResolution.KEY_RESOLUTION_WIDTH, resolutionWidth); + setDisplayType(type) { + this.validateType(DisplayType, type); + this.setParameter(DisplayCapabilities.KEY_DISPLAY_TYPE, type); return this; } /** - * @return {Number} - */ + * @deprecated + * @return {DisplayType} + */ - getResolutionWidth() { - return this.getParameter(ImageResolution.KEY_RESOLUTION_WIDTH); + getDisplayType() { + return this.getObject(DisplayType, DisplayCapabilities.KEY_DISPLAY_TYPE); } /** - * @param {Number} resolutionHeight - * @return {ImageResolution} - */ + * @deprecated + * @param {String} name - The name of the display the app is connected to. + * @return {DisplayCapabilities} + */ - setResolutionHeight(resolutionHeight) { - this.setParameter(ImageResolution.KEY_RESOLUTION_HEIGHT, resolutionHeight); + setDisplayName(name) { + this.setParameter(DisplayCapabilities.KEY_DISPLAY_NAME, name); return this; } /** - * @return {Number} - */ - - - getResolutionHeight() { - return this.getParameter(ImageResolution.KEY_RESOLUTION_HEIGHT); - } - - } - - ImageResolution.KEY_RESOLUTION_WIDTH = 'resolutionWidth'; - ImageResolution.KEY_RESOLUTION_HEIGHT = 'resolutionHeight'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} ImageFieldName - * @property {Object} _MAP - */ - - class ImageFieldName extends Enum { - constructor() { - super(); - } - /** - * @return {String} - */ - - - static get softButtonImage() { - return ImageFieldName._MAP.softButtonImage; - } - /** - * @return {String} - */ + * @deprecated + * @return {String} + */ - static get choiceImage() { - return ImageFieldName._MAP.choiceImage; + getDisplayName() { + return this.getParameter(DisplayCapabilities.KEY_DISPLAY_NAME); } /** - * @return {String} - */ + * @deprecated + * @param {TextField[]} fields - A set of all fields that support text data. See TextField + * @return {DisplayCapabilities} + */ - static get choiceSecondaryImage() { - return ImageFieldName._MAP.choiceSecondaryImage; + setTextFields(fields) { + this.validateType(TextField, fields, true); + this.setParameter(DisplayCapabilities.KEY_TEXT_FIELDS, fields); + return this; } /** - * @return {String} - */ + * @deprecated + * @return {TextField[]} + */ - static get vrHelpItem() { - return ImageFieldName._MAP.vrHelpItem; + getTextFields() { + return this.getObject(TextField, DisplayCapabilities.KEY_TEXT_FIELDS); } /** - * @return {String} - */ + * @deprecated + * @param {ImageField[]} fields - A set of all fields that support images. See ImageField + * @return {DisplayCapabilities} + */ - static get turnIcon() { - return ImageFieldName._MAP.turnIcon; + setImageFields(fields) { + this.validateType(ImageField, fields, true); + this.setParameter(DisplayCapabilities.KEY_IMAGE_FIELDS, fields); + return this; } /** - * @return {String} - */ + * @deprecated + * @return {ImageField[]} + */ - static get menuIcon() { - return ImageFieldName._MAP.menuIcon; + getImageFields() { + return this.getObject(ImageField, DisplayCapabilities.KEY_IMAGE_FIELDS); } /** - * @return {String} - */ + * @deprecated + * @param {MediaClockFormat[]} formats - A set of all supported formats of the media clock. See MediaClockFormat + * @return {DisplayCapabilities} + */ - static get cmdIcon() { - return ImageFieldName._MAP.cmdIcon; + setMediaClockFormats(formats) { + this.validateType(MediaClockFormat, formats, true); + this.setParameter(DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS, formats); + return this; } /** - * @return {String} - */ + * @deprecated + * @return {MediaClockFormat[]} + */ - static get appIcon() { - return ImageFieldName._MAP.appIcon; + getMediaClockFormats() { + return this.getObject(MediaClockFormat, DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS); } /** - * @return {String} - */ + * @deprecated + * @param {Boolean} supported - The display's persistent screen supports referencing a static or dynamic image. + * @return {DisplayCapabilities} + */ - static get graphic() { - return ImageFieldName._MAP.graphic; + setGraphicSupported(supported) { + this.setParameter(DisplayCapabilities.KEY_GRAPHIC_SUPPORTED, supported); + return this; } /** - * @return {String} - */ + * @deprecated + * @return {Boolean} + */ - static get secondaryGraphic() { - return ImageFieldName._MAP.secondaryGraphic; + getGraphicSupported() { + return this.getParameter(DisplayCapabilities.KEY_GRAPHIC_SUPPORTED); } /** - * @return {String} - */ + * @deprecated + * @param {String[]} available - A set of all predefined persistent display templates available on headunit. To be + * referenced in SetDisplayLayout. + * @return {DisplayCapabilities} + */ - static get showConstantTBTIcon() { - return ImageFieldName._MAP.showConstantTBTIcon; + setTemplatesAvailable(available) { + this.setParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE, available); + return this; } /** - * @return {String} - */ + * @deprecated + * @return {String[]} + */ - static get showConstantTBTNextTurnIcon() { - return ImageFieldName._MAP.showConstantTBTNextTurnIcon; + getTemplatesAvailable() { + return this.getParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE); } /** - * @return {String} - */ + * @deprecated + * @param {ScreenParams} params - A set of all parameters related to a prescribed screen area (e.g. for video / + * touch input). + * @return {DisplayCapabilities} + */ - static get locationImage() { - return ImageFieldName._MAP.locationImage; + setScreenParams(params) { + this.validateType(ScreenParams, params); + this.setParameter(DisplayCapabilities.KEY_SCREEN_PARAMS, params); + return this; } /** - * @return {String} - */ + * @deprecated + * @return {ScreenParams} + */ - static get alertIcon() { - return ImageFieldName._MAP.alertIcon; + getScreenParams() { + return this.getObject(ScreenParams, DisplayCapabilities.KEY_SCREEN_PARAMS); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @deprecated + * @param {Number} available - The number of on-screen custom presets available (if any); otherwise omitted. + * @return {DisplayCapabilities} + */ - static valueForKey(key) { - return ImageFieldName._valueForKey(key, ImageFieldName._MAP); + setNumCustomPresetsAvailable(available) { + this.setParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, available); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @deprecated + * @return {Number} + */ - static keyForValue(value) { - return ImageFieldName._keyForValue(value, ImageFieldName._MAP); + getNumCustomPresetsAvailable() { + return this.getParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE); } } - ImageFieldName._MAP = Object.freeze({ - 'softButtonImage': 'softButtonImage', - 'choiceImage': 'choiceImage', - 'choiceSecondaryImage': 'choiceSecondaryImage', - 'vrHelpItem': 'vrHelpItem', - 'turnIcon': 'turnIcon', - 'menuIcon': 'menuIcon', - 'cmdIcon': 'cmdIcon', - 'appIcon': 'appIcon', - 'graphic': 'graphic', - 'secondaryGraphic': 'secondaryGraphic', - 'showConstantTBTIcon': 'showConstantTBTIcon', - 'showConstantTBTNextTurnIcon': 'showConstantTBTNextTurnIcon', - 'locationImage': 'locationImage', - 'alertIcon': 'alertIcon' - }); + DisplayCapabilities.KEY_DISPLAY_TYPE = 'displayType'; + DisplayCapabilities.KEY_DISPLAY_NAME = 'displayName'; + DisplayCapabilities.KEY_TEXT_FIELDS = 'textFields'; + DisplayCapabilities.KEY_IMAGE_FIELDS = 'imageFields'; + DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS = 'mediaClockFormats'; + DisplayCapabilities.KEY_GRAPHIC_SUPPORTED = 'graphicSupported'; + DisplayCapabilities.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable'; + DisplayCapabilities.KEY_SCREEN_PARAMS = 'screenParams'; + DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Describes different sampling options for PerformAudioPassThru. + * @typedef {Enum} SamplingRate + * @property {Object} _MAP + */ - class ImageField extends RpcStruct { - constructor(parameters) { - super(parameters); + class SamplingRate extends Enum { + /** + * @constructor + */ + constructor() { + super(); } /** - * @param {ImageFieldName} imageFieldName - * @return {ImageField} - */ + * Sampling rate of 8000 Hz. + * @return {String} + */ - setImageFieldName(imageFieldName) { - this.validateType(ImageFieldName, imageFieldName); - this.setParameter(ImageField.KEY_NAME, imageFieldName); - return this; + static get SamplingRate_8KHZ() { + return SamplingRate._MAP.SamplingRate_8KHZ; } /** - * @return {ImageFieldName} - */ + * Sampling rate of 16000 Hz. + * @return {String} + */ - getImageFieldName() { - return this.getObject(ImageFieldName, ImageField.KEY_NAME); + static get SamplingRate_16KHZ() { + return SamplingRate._MAP.SamplingRate_16KHZ; } /** - * @param {FileType[]} imageTypeSupported - * @return {ImageField} - */ + * Sampling rate of 22050 Hz. + * @return {String} + */ - setImageTypeSupported(imageTypeSupported) { - this.validateType(FileType, imageTypeSupported, true); - this.setParameter(ImageField.KEY_IMAGE_TYPE_SUPPORTED, imageTypeSupported); - return this; + static get SamplingRate_22KHZ() { + return SamplingRate._MAP.SamplingRate_22KHZ; } /** - * @return {FileType} - */ + * Sampling rate of 44100 Hz. + * @return {String} + */ - getImageTypeSupported() { - return this.getObject(FileType, ImageField.KEY_IMAGE_TYPE_SUPPORTED); + static get SamplingRate_44KHZ() { + return SamplingRate._MAP.SamplingRate_44KHZ; } /** - * @param {ImageResolution} imageResolution - * @return {ImageField} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - setImageResolution(imageResolution) { - this.validateType(ImageResolution, imageResolution); - this.setParameter(ImageField.KEY_IMAGE_RESOLUTION, imageResolution); - return this; + static valueForKey(key) { + return SamplingRate._valueForKey(key, SamplingRate._MAP); } /** - * @return {ImageResolution} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - getImageResolution() { - return this.getObject(ImageResolution, ImageField.KEY_IMAGE_RESOLUTION); + static keyForValue(value) { + return SamplingRate._keyForValue(value, SamplingRate._MAP); } } - ImageField.KEY_NAME = 'name'; - ImageField.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported'; - ImageField.KEY_IMAGE_RESOLUTION = 'imageResolution'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - class TouchEventCapabilities extends RpcStruct { - constructor(parameters) { - super(parameters); - } - /** - * @param {Boolean} pressAvailable - * @return {TouchEventCapabilities} - */ + SamplingRate._MAP = Object.freeze({ + 'SamplingRate_8KHZ': '8KHZ', + 'SamplingRate_16KHZ': '16KHZ', + 'SamplingRate_22KHZ': '22KHZ', + 'SamplingRate_44KHZ': '44KHZ' + }); + /* eslint-disable camelcase */ + /** + * Describes different quality options for PerformAudioPassThru. + * @typedef {Enum} BitsPerSample + * @property {Object} _MAP + */ - setPressAvailable(pressAvailable) { - this.setParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE, pressAvailable); - return this; - } + class BitsPerSample extends Enum { /** - * @return {Boolean} - */ - - - getPressAvailable() { - return this.getParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE); + * @constructor + */ + constructor() { + super(); } /** - * @param {Boolean} multiTouchAvailable - * @return {TouchEventCapabilities} - */ + * Audio sample is 8 bits wide, unsigned. + * @return {String} + */ - setMultiTouchAvailable(multiTouchAvailable) { - this.setParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE, multiTouchAvailable); - return this; + static get BitsPerSample_8_BIT() { + return BitsPerSample._MAP.BitsPerSample_8_BIT; } /** - * @return {Boolean} - */ + * Audio sample is 16 bits wide, signed, and in little endian. + * @return {String} + */ - getMultiTouchAvailable() { - return this.getParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE); + static get BitsPerSample_16_BIT() { + return BitsPerSample._MAP.BitsPerSample_16_BIT; } /** - * @param {Boolean} doublePressAvailable - * @return {TouchEventCapabilities} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - setDoublePressAvailable(doublePressAvailable) { - this.setParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE, doublePressAvailable); - return this; + static valueForKey(key) { + return BitsPerSample._valueForKey(key, BitsPerSample._MAP); } /** - * @return {Boolean} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - getDoublePressAvailable() { - return this.getParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE); + static keyForValue(value) { + return BitsPerSample._keyForValue(value, BitsPerSample._MAP); } } - TouchEventCapabilities.KEY_PRESS_AVAILABLE = 'pressAvailable'; - TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE = 'multiTouchAvailable'; - TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE = 'doublePressAvailable'; + BitsPerSample._MAP = Object.freeze({ + 'BitsPerSample_8_BIT': '8_BIT', + 'BitsPerSample_16_BIT': '16_BIT' + }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Describes different audio type options for PerformAudioPassThru. + * @typedef {Enum} AudioType + * @property {Object} _MAP + */ - class ScreenParams extends RpcStruct { - constructor(parameters) { - super(parameters); - } + class AudioType extends Enum { /** - * @param {ImageResolution} resolution - * @return {ScreenParams} - */ - - - setResolution(resolution) { - this.validateType(ImageResolution, resolution); - this.setParameter(ScreenParams.KEY_RESOLUTION, resolution); - return this; + * @constructor + */ + constructor() { + super(); } /** - * @return {ImageResolution} - */ + * Linear PCM. + * @return {String} + */ - getResolution() { - return this.getObject(ImageResolution, ScreenParams.KEY_RESOLUTION); + static get PCM() { + return AudioType._MAP.PCM; } /** - * @param {TouchEventCapabilities} touchEventCapabilities - * @return {ScreenParams} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - setTouchEventAvailable(touchEventCapabilities) { - this.validateType(TouchEventCapabilities, touchEventCapabilities); - this.setParameter(ScreenParams.KEY_TOUCH_EVENT_AVAILABLE, touchEventCapabilities); - return this; + static valueForKey(key) { + return AudioType._valueForKey(key, AudioType._MAP); } /** - * @return {TouchEventCapabilities} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - getTouchEventAvailable() { - return this.getObject(TouchEventCapabilities, ScreenParams.KEY_TOUCH_EVENT_AVAILABLE); + static keyForValue(value) { + return AudioType._keyForValue(value, AudioType._MAP); } } - ScreenParams.KEY_RESOLUTION = 'resolution'; - ScreenParams.KEY_TOUCH_EVENT_AVAILABLE = 'touchEventAvailable'; + AudioType._MAP = Object.freeze({ + 'PCM': 'PCM' + }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} DisplayType - * @property {Object} _MAP + * Describes different audio type configurations for PerformAudioPassThru. e.g. {8kHz,8-bit,PCM} The audio is recorded + * in monaural. */ - class DisplayType extends Enum { - constructor() { - super(); - } + class AudioPassThruCapabilities extends RpcStruct { /** - * @return {String} + * @constructor */ - - - static get CID() { - return DisplayType._MAP.CID; + constructor(parameters) { + super(parameters); } /** - * @return {String} + * @param {SamplingRate} rate - Describes different sampling options for PerformAudioPassThru. + * @return {AudioPassThruCapabilities} */ - static get TYPE2() { - return DisplayType._MAP.TYPE2; + setSamplingRate(rate) { + this.validateType(SamplingRate, rate); + this.setParameter(AudioPassThruCapabilities.KEY_SAMPLING_RATE, rate); + return this; } /** - * @return {String} + * @return {SamplingRate} */ - static get TYPE5() { - return DisplayType._MAP.TYPE5; + getSamplingRate() { + return this.getObject(SamplingRate, AudioPassThruCapabilities.KEY_SAMPLING_RATE); } /** - * @return {String} + * @param {BitsPerSample} sample - Describes different quality options for PerformAudioPassThru. + * @return {AudioPassThruCapabilities} */ - static get NGN() { - return DisplayType._MAP.NGN; + setBitsPerSample(sample) { + this.validateType(BitsPerSample, sample); + this.setParameter(AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE, sample); + return this; } /** - * @return {String} + * @return {BitsPerSample} */ - static get GEN2_8_DMA() { - return DisplayType._MAP.GEN2_8_DMA; + getBitsPerSample() { + return this.getObject(BitsPerSample, AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE); } /** - * @return {String} + * @param {AudioType} type - Describes different audio type options for PerformAudioPassThru. + * @return {AudioPassThruCapabilities} */ - static get GEN2_6_DMA() { - return DisplayType._MAP.GEN2_6_DMA; + setAudioType(type) { + this.validateType(AudioType, type); + this.setParameter(AudioPassThruCapabilities.KEY_AUDIO_TYPE, type); + return this; } /** - * @return {String} + * @return {AudioType} */ - static get MFD3() { - return DisplayType._MAP.MFD3; + getAudioType() { + return this.getObject(AudioType, AudioPassThruCapabilities.KEY_AUDIO_TYPE); } - /** - * @return {String} - */ + } - static get MFD4() { - return DisplayType._MAP.MFD4; - } - /** - * @return {String} - */ + AudioPassThruCapabilities.KEY_SAMPLING_RATE = 'samplingRate'; + AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE = 'bitsPerSample'; + AudioPassThruCapabilities.KEY_AUDIO_TYPE = 'audioType'; + /* eslint-disable camelcase */ + /** + * Contains information about the VR capabilities. + * @typedef {Enum} VrCapabilities + * @property {Object} _MAP + */ - static get MFD5() { - return DisplayType._MAP.MFD5; - } + class VrCapabilities extends Enum { /** - * @return {String} + * @constructor */ - - - static get GEN3_8_INCH() { - return DisplayType._MAP.GEN3_8_INCH; + constructor() { + super(); } /** * @return {String} */ - static get SDL_GENERIC() { - return DisplayType._MAP.SDL_GENERIC; + static get VR_TEXT() { + return VrCapabilities._MAP.VR_TEXT; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { - return DisplayType._valueForKey(key, DisplayType._MAP); + return VrCapabilities._valueForKey(key, VrCapabilities._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return DisplayType._keyForValue(value, DisplayType._MAP); + return VrCapabilities._keyForValue(value, VrCapabilities._MAP); } } - DisplayType._MAP = Object.freeze({ - 'CID': 'CID', - 'TYPE2': 'TYPE2', - 'TYPE5': 'TYPE5', - 'NGN': 'NGN', - 'GEN2_8_DMA': 'GEN2_8_DMA', - 'GEN2_6_DMA': 'GEN2_6_DMA', - 'MFD3': 'MFD3', - 'MFD4': 'MFD4', - 'TESTING': 'TESTING', - 'MFD5': 'MFD5', - 'GEN3_8_INCH': 'GEN3_8-INCH', - 'SDL_GENERIC': 'SDL_GENERIC' + VrCapabilities._MAP = Object.freeze({ + 'VR_TEXT': 'TEXT' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} MediaClockFormat + * Defines the hard (physical) and soft (touchscreen) buttons available from the module + * @typedef {Enum} ButtonName * @property {Object} _MAP */ - class MediaClockFormat extends Enum { + class ButtonName extends Enum { + /** + * @constructor + */ constructor() { super(); } @@ -20613,792 +19907,169 @@ */ - static get CLOCK1() { - return MediaClockFormat._MAP.CLOCK1; + static get OK() { + return ButtonName._MAP.OK; } /** + * The button name for the physical Play/Pause toggle that can be used by media apps. * @return {String} */ - static get CLOCK2() { - return MediaClockFormat._MAP.CLOCK2; + static get PLAY_PAUSE() { + return ButtonName._MAP.PLAY_PAUSE; } /** * @return {String} */ - static get CLOCK3() { - return MediaClockFormat._MAP.CLOCK3; + static get SEEKLEFT() { + return ButtonName._MAP.SEEKLEFT; } /** * @return {String} */ - static get CLOCKTEXT1() { - return MediaClockFormat._MAP.CLOCKTEXT1; + static get SEEKRIGHT() { + return ButtonName._MAP.SEEKRIGHT; } /** * @return {String} */ - static get CLOCKTEXT2() { - return MediaClockFormat._MAP.CLOCKTEXT2; + static get TUNEUP() { + return ButtonName._MAP.TUNEUP; } /** * @return {String} */ - static get CLOCKTEXT3() { - return MediaClockFormat._MAP.CLOCKTEXT3; + static get TUNEDOWN() { + return ButtonName._MAP.TUNEDOWN; } /** * @return {String} */ - static get CLOCKTEXT4() { - return MediaClockFormat._MAP.CLOCKTEXT4; + static get PRESET_0() { + return ButtonName._MAP.PRESET_0; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @return {String} + */ - static valueForKey(key) { - return MediaClockFormat._valueForKey(key, MediaClockFormat._MAP); + static get PRESET_1() { + return ButtonName._MAP.PRESET_1; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @return {String} + */ - static keyForValue(value) { - return MediaClockFormat._keyForValue(value, MediaClockFormat._MAP); + static get PRESET_2() { + return ButtonName._MAP.PRESET_2; } + /** + * @return {String} + */ - } - - MediaClockFormat._MAP = Object.freeze({ - 'CLOCK1': 'CLOCK1', - 'CLOCK2': 'CLOCK2', - 'CLOCK3': 'CLOCK3', - 'CLOCKTEXT1': 'CLOCKTEXT1', - 'CLOCKTEXT2': 'CLOCKTEXT2', - 'CLOCKTEXT3': 'CLOCKTEXT3', - 'CLOCKTEXT4': 'CLOCKTEXT4' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class DisplayCapabilities extends RpcStruct { - constructor(parameters) { - super(parameters); + static get PRESET_3() { + return ButtonName._MAP.PRESET_3; } /** - * @param {DisplayType} displayType - * @return {DisplayCapabilities} - */ + * @return {String} + */ - setDisplayType(displayType) { - this.validateType(DisplayType, displayType); - this.setParameter(DisplayCapabilities.KEY_DISPLAY_TYPE, displayType); - return this; + static get PRESET_4() { + return ButtonName._MAP.PRESET_4; } /** - * @return {DisplayType} - */ + * @return {String} + */ - getDisplayType() { - return this.getObject(DisplayType, DisplayCapabilities.KEY_DISPLAY_TYPE); + static get PRESET_5() { + return ButtonName._MAP.PRESET_5; } /** - * @param {String} displayName - * @return {DisplayCapabilities} - */ + * @return {String} + */ - setDisplayName(displayName) { - this.setParameter(DisplayCapabilities.KEY_DISPLAY_NAME, displayName); - return this; + static get PRESET_6() { + return ButtonName._MAP.PRESET_6; } /** - * @return {String} - */ + * @return {String} + */ - getDisplayName() { - return this.getParameter(DisplayCapabilities.KEY_DISPLAY_NAME); + static get PRESET_7() { + return ButtonName._MAP.PRESET_7; } /** - * @param {Array} textFields - * @return {DisplayCapabilities} - */ + * @return {String} + */ - setTextFields(textFields) { - // TODO make work with arrays - // this.validateType(TextField, textFields); - this.setParameter(DisplayCapabilities.KEY_TEXT_FIELDS, textFields); - return this; + static get PRESET_8() { + return ButtonName._MAP.PRESET_8; } /** - * @return {Array} - */ + * @return {String} + */ - getTextFields() { - return this.getObject(TextField, DisplayCapabilities.KEY_TEXT_FIELDS); + static get PRESET_9() { + return ButtonName._MAP.PRESET_9; } /** - * @param {Array} imageFields - * @return {DisplayCapabilities} - */ + * @return {String} + */ - setImageFields(imageFields) { - // TODO make work with arrays - // this.validateType(ImageField, imageFields); - this.setParameter(DisplayCapabilities.KEY_IMAGE_FIELDS, imageFields); - return this; + static get CUSTOM_BUTTON() { + return ButtonName._MAP.CUSTOM_BUTTON; } /** - * @return {Array} - */ + * @return {String} + */ - getImageFields() { - return this.getObject(ImageField, DisplayCapabilities.KEY_IMAGE_FIELDS); + static get SEARCH() { + return ButtonName._MAP.SEARCH; } /** - * @param {Array} mediaClockFormats - * @return {DisplayCapabilities} - */ + * @return {String} + */ - setMediaClockFormats(mediaClockFormats) { - // TODO make work with arrays - // this.validateType(ImageField, mediaClockFormats); - this.setParameter(DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS, mediaClockFormats); - return this; + static get AC_MAX() { + return ButtonName._MAP.AC_MAX; } /** - * @return {Array} - */ + * @return {String} + */ - getMediaClockFormats() { - return this.getObject(MediaClockFormat, DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS); + static get AC() { + return ButtonName._MAP.AC; } /** - * @param {Boolean} graphicSupported - * @return {DisplayCapabilities} - */ + * @return {String} + */ - setGraphicsSupported(graphicSupported) { - this.setParameter(DisplayCapabilities.KEY_GRAPHICS_SUPPORTED, graphicSupported); - return this; - } - /** - * @return {Boolean} - */ - - - getGraphicsSupported() { - return this.getParameter(DisplayCapabilities.KEY_GRAPHICS_SUPPORTED); - } - /** - * @param {Array} templatesAvailable - * @return {DisplayCapabilities} - */ - - - setTemplatesAvailable(templatesAvailable) { - // TODO make work with arrays - // this.validateType(String, templatesAvailable); - this.setParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE, templatesAvailable); - return this; - } - /** - * @return {Array} - */ - - - getTemplatesAvailable() { - return this.getParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE); - } - /** - * @param {ScreenParams} screenParams - * @return {DisplayCapabilities} - */ - - - setScreenParams(screenParams) { - this.validateType(ScreenParams, screenParams); - this.setParameter(DisplayCapabilities.KEY_SCREEN_PARAMS, screenParams); - return this; - } - /** - * @return {ScreenParams} - */ - - - getScreenParams() { - return this.getObject(ScreenParams, DisplayCapabilities.KEY_SCREEN_PARAMS); - } - /** - * @param {Array} numCustomPresetsAvailable - * @return {DisplayCapabilities} - */ - - - setNumCustomPresetsAvailable(numCustomPresetsAvailable) { - // TODO make work with arrays - // this.validateType(Number, numCustomPresetsAvailable); - this.setParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, numCustomPresetsAvailable); - return this; - } - /** - * @return {Array} - */ - - - getNumCustomPresetsAvailable() { - return this.getParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE); - } - - } - - DisplayCapabilities.KEY_DISPLAY_TYPE = 'displayType'; - DisplayCapabilities.KEY_DISPLAY_NAME = 'displayName'; - DisplayCapabilities.KEY_TEXT_FIELDS = 'textFields'; - DisplayCapabilities.KEY_IMAGE_FIELDS = 'imageFields'; - DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS = 'mediaClockFormats'; - DisplayCapabilities.KEY_GRAPHICS_SUPPORTED = 'graphicSupported'; - DisplayCapabilities.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable'; - DisplayCapabilities.KEY_SCREEN_PARAMS = 'screenParams'; - DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - class Grid extends RpcStruct { - constructor(parameters) { - super(parameters); - } - /** - * @param {Number} column - * @return {Grid} - */ - - - setColumn(column) { - this.setParameter(Grid.KEY_COLUMN, column); - return this; - } - /** - * @return {Number} - */ - - - getColumn() { - return this.getParameter(Grid.KEY_COLUMN); - } - /** - * @param {Number} row - * @return {Grid} - */ - - - setRow(row) { - this.setParameter(Grid.KEY_ROW, row); - return this; - } - /** - * @return {Number} - */ - - - getRow() { - return this.getParameter(Grid.KEY_ROW); - } - /** - * @param {Number} level - * @return {Grid} - */ - - - setLevel(level) { - this.setParameter(Grid.KEY_LEVEL, level); - return this; - } - /** - * @return {Number} - */ - - - getLevel() { - return this.getParameter(Grid.KEY_LEVEL); - } - /** - * @param {Number} columnSpan - * @return {Grid} - */ - - - setColumnSpan(columnSpan) { - this.setParameter(Grid.KEY_COLUMN_SPAN, columnSpan); - return this; - } - /** - * @return {Number} - */ - - - getColumnSpan() { - return this.getParameter(Grid.KEY_COLUMN_SPAN); - } - /** - * @param {Number} rowSpan - * @return {Grid} - */ - - - setRowSpan(rowSpan) { - this.setParameter(Grid.KEY_ROW_SPAN, rowSpan); - return this; - } - /** - * @return {Number} - */ - - - getRowSpan() { - return this.getParameter(Grid.KEY_ROW_SPAN); - } - /** - * @param {Number} levelSpan - * @return {Grid} - */ - - - setLevelSpan(levelSpan) { - this.setParameter(Grid.KEY_LEVEL_SPAN, levelSpan); - return this; - } - /** - * @return {Number} - */ - - - getLevelSpan() { - return this.getParameter(Grid.KEY_LEVEL_SPAN); - } - - } - - Grid.KEY_COLUMN = 'col'; - Grid.KEY_ROW = 'row'; - Grid.KEY_LEVEL = 'level'; - Grid.KEY_COLUMN_SPAN = 'colspan'; - Grid.KEY_ROW_SPAN = 'rowspan'; - Grid.KEY_LEVEL_SPAN = 'levelspan'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - class ModuleInfo extends RpcStruct { - constructor(parameters) { - super(parameters); - } - /** - * @param {String} moduleId - * @return {ModuleInfo} - */ - - - setModuleId(moduleId) { - this.setParameter(ModuleInfo.KEY_MODULE_ID, moduleId); - return this; - } - /** - * @return {String} - */ - - - getModuleId() { - return this.getParameter(ModuleInfo.KEY_MODULE_ID); - } - /** - * @param {Grid} location - * @return {ModuleInfo} - */ - - - setLocation(location) { - this.validateType(Grid, location); - this.setParameter(ModuleInfo.KEY_LOCATION, location); - return this; - } - /** - * @return {Grid} - */ - - - getLocation() { - return this.getObject(Grid, ModuleInfo.KEY_LOCATION); - } - /** - * @param {Grid} serviceArea - * @return {ModuleInfo} - */ - - - setServiceArea(serviceArea) { - this.validateType(Grid, serviceArea); - this.setParameter(ModuleInfo.KEY_SERVICE_AREA, serviceArea); - return this; - } - /** - * @return {Grid} - */ - - - getServiceArea() { - return this.getObject(Grid, ModuleInfo.KEY_SERVICE_AREA); - } - /** - * @param {Boolean} allowMultipleAccess - * @return {ModuleInfo} - */ - - - setAllowMultipleAccess(allowMultipleAccess) { - this.setParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS, allowMultipleAccess); - return this; - } - /** - * @return {Boolean} - */ - - - getAllowMultipleAccess() { - return this.getParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS); - } - - } - - ModuleInfo.KEY_MODULE_ID = 'moduleId'; - ModuleInfo.KEY_LOCATION = 'location'; - ModuleInfo.KEY_SERVICE_AREA = 'serviceArea'; - ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS = 'allowMultipleAccess'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} ButtonName - * @property {Object} _MAP - */ - - class ButtonName extends Enum { - constructor() { - super(); - } - /** - * @return {String} - */ - - - static get OK() { - return ButtonName._MAP.OK; - } - /** - * @return {String} - */ - - - static get PLAY_PAUSE() { - return ButtonName._MAP.PLAY_PAUSE; - } - /** - * @return {String} - */ - - - static get SEEKLEFT() { - return ButtonName._MAP.SEEKLEFT; - } - /** - * @return {String} - */ - - - static get SEEKRIGHT() { - return ButtonName._MAP.SEEKRIGHT; - } - /** - * @return {String} - */ - - - static get TUNEUP() { - return ButtonName._MAP.TUNEUP; - } - /** - * @return {String} - */ - - - static get TUNEDOWN() { - return ButtonName._MAP.TUNEDOWN; - } - /** - * @return {String} - */ - - - static get PRESET_0() { - return ButtonName._MAP.PRESET_0; - } - /** - * @return {String} - */ - - - static get PRESET_1() { - return ButtonName._MAP.PRESET_1; - } - /** - * @return {String} - */ - - - static get PRESET_2() { - return ButtonName._MAP.PRESET_2; - } - /** - * @return {String} - */ - - - static get PRESET_3() { - return ButtonName._MAP.PRESET_3; - } - /** - * @return {String} - */ - - - static get PRESET_4() { - return ButtonName._MAP.PRESET_4; - } - /** - * @return {String} - */ - - - static get PRESET_5() { - return ButtonName._MAP.PRESET_5; - } - /** - * @return {String} - */ - - - static get PRESET_6() { - return ButtonName._MAP.PRESET_6; - } - /** - * @return {String} - */ - - - static get PRESET_7() { - return ButtonName._MAP.PRESET_7; - } - /** - * @return {String} - */ - - - static get PRESET_8() { - return ButtonName._MAP.PRESET_8; - } - /** - * @return {String} - */ - - - static get PRESET_9() { - return ButtonName._MAP.PRESET_9; - } - /** - * @return {String} - */ - - - static get CUSTOM_BUTTON() { - return ButtonName._MAP.CUSTOM_BUTTON; - } - /** - * @return {String} - */ - - - static get SEARCH() { - return ButtonName._MAP.SEARCH; - } - /** - * @return {String} - */ - - - static get AC_MAX() { - return ButtonName._MAP.AC_MAX; - } - /** - * @return {String} - */ - - - static get AC() { - return ButtonName._MAP.AC; - } - /** - * @return {String} - */ - - - static get RECIRCULATE() { - return ButtonName._MAP.RECIRCULATE; + static get RECIRCULATE() { + return ButtonName._MAP.RECIRCULATE; } /** * @return {String} @@ -21609,6 +20280,9 @@ return ButtonName._MAP.NAV_PAN_UP_LEFT; } /** + * If supported, this toggles between a top-down view and an angled/3D view. If your app supports different, but + * substantially similar options, then you may implement those. If you don't implement these or similar options, + * do not subscribe to this button. * @return {String} */ @@ -21633,6 +20307,9 @@ return ButtonName._MAP.NAV_ROTATE_COUNTERCLOCKWISE; } /** + * If supported, this toggles between locking the orientation to north or to the vehicle's heading. If your app + * supports different, but substantially similar options, then you may implement those. If you don't implement + * these or similar options, do not subscribe to this button. * @return {String} */ @@ -21641,20 +20318,20 @@ return ButtonName._MAP.NAV_HEADING_TOGGLE; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { return ButtonName._valueForKey(key, ButtonName._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { @@ -21717,1828 +20394,1427 @@ 'NAV_HEADING_TOGGLE': 'NAV_HEADING_TOGGLE' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Describes a location (origin coordinates and span) of a vehicle component. + */ - class ButtonCapabilities extends RpcStruct { + class Grid extends RpcStruct { + /** + * @constructor + */ constructor(parameters) { super(parameters); } /** - * @param {ButtonName} name - * @return {ButtonCapabilities} - */ + * @param {Number} col + * @return {Grid} + */ - setName(name) { - this.validateType(ButtonName, name); - this.setParameter(ButtonCapabilities.KEY_NAME, name); + setColumn(col) { + this.setParameter(Grid.KEY_COLUMN, col); return this; } /** - * @return {ButtonName} - */ + * @return {Number} + */ - getName() { - return this.getObject(ButtonName, ButtonCapabilities.KEY_NAME); + getColumn() { + return this.getParameter(Grid.KEY_COLUMN); } /** - * @param {ModuleInfo} moduleInfo - * @return {ButtonCapabilities} - */ + * @param {Number} row + * @return {Grid} + */ - setModuleInfo(moduleInfo) { - this.validateType(ModuleInfo, moduleInfo); - this.setParameter(ButtonCapabilities.KEY_MODULE_INFO, moduleInfo); + setRow(row) { + this.setParameter(Grid.KEY_ROW, row); return this; } /** - * @return {ModuleInfo} - */ + * @return {Number} + */ - getModuleInfo() { - return this.getObject(ModuleInfo, ButtonCapabilities.KEY_MODULE_INFO); + getRow() { + return this.getParameter(Grid.KEY_ROW); } /** - * @param {Boolean} shortPressAvailable - * @return {ButtonCapabilities} - */ + * @param {Number} level + * @return {Grid} + */ - setShortPressAvailable(shortPressAvailable) { - this.setParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, shortPressAvailable); + setLevel(level) { + this.setParameter(Grid.KEY_LEVEL, level); return this; } /** - * @return {Boolean} - */ + * @return {Number} + */ - getShortPressAvailable() { - return this.getParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE); + getLevel() { + return this.getParameter(Grid.KEY_LEVEL); } /** - * @param {Boolean} longPressAvailable - * @return {ButtonCapabilities} - */ + * @param {Number} colspan + * @return {Grid} + */ - setLongPressAvailable(longPressAvailable) { - this.setParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, longPressAvailable); + setColumnSpan(colspan) { + this.setParameter(Grid.KEY_COLUMN_SPAN, colspan); return this; } /** - * @return {Boolean} - */ + * @return {Number} + */ - getLongPressAvailable() { - return this.getParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE); + getColumnSpan() { + return this.getParameter(Grid.KEY_COLUMN_SPAN); } /** - * @param {Boolean} upDownAvailable - * @return {ButtonCapabilities} - */ + * @param {Number} rowspan + * @return {Grid} + */ - setUpDownAvailable(upDownAvailable) { - this.setParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE, upDownAvailable); + setRowSpan(rowspan) { + this.setParameter(Grid.KEY_ROW_SPAN, rowspan); return this; } /** - * @return {Boolean} - */ + * @return {Number} + */ - getUpDownAvailable() { - return this.getParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE); + getRowSpan() { + return this.getParameter(Grid.KEY_ROW_SPAN); } + /** + * @param {Number} levelspan + * @return {Grid} + */ - } - - ButtonCapabilities.KEY_NAME = 'name'; - ButtonCapabilities.KEY_MODULE_INFO = 'moduleInfo'; - ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable'; - ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable'; - ButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class SoftButtonCapabilities extends RpcStruct { - constructor(parameters) { - super(parameters); + setLevelSpan(levelspan) { + this.setParameter(Grid.KEY_LEVEL_SPAN, levelspan); + return this; } /** - * @param {Boolean} shortPressAvailable - * @return {SoftButtonCapabilities} - */ + * @return {Number} + */ - setShortPressAvailable(shortPressAvailable) { - this.setParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, shortPressAvailable); - return this; + getLevelSpan() { + return this.getParameter(Grid.KEY_LEVEL_SPAN); } - /** - * @return {Boolean} - */ + } - getShortPressAvailable() { - return this.getParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE); + Grid.KEY_COLUMN = 'col'; + Grid.KEY_ROW = 'row'; + Grid.KEY_LEVEL = 'level'; + Grid.KEY_COLUMN_SPAN = 'colspan'; + Grid.KEY_ROW_SPAN = 'rowspan'; + Grid.KEY_LEVEL_SPAN = 'levelspan'; + + /* eslint-disable camelcase */ + /** + * Information about a RC module + */ + + class ModuleInfo extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @param {Boolean} longPressAvailable - * @return {SoftButtonCapabilities} - */ + * @param {String} id - uuid of a module. "moduleId + moduleType" uniquely identify a module. + * @return {ModuleInfo} + */ - setLongPressAvailable(longPressAvailable) { - this.setParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, longPressAvailable); + setModuleId(id) { + this.setParameter(ModuleInfo.KEY_MODULE_ID, id); return this; } /** - * @return {Boolean} - */ + * @return {String} + */ - getLongPressAvailable() { - return this.getParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE); + getModuleId() { + return this.getParameter(ModuleInfo.KEY_MODULE_ID); } /** - * @param {Boolean} upDownAvailable - * @return {SoftButtonCapabilities} - */ + * @param {Grid} location - Location of a module. + * @return {ModuleInfo} + */ - setUpDownAvailable(upDownAvailable) { - this.setParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE, upDownAvailable); + setLocation(location) { + this.validateType(Grid, location); + this.setParameter(ModuleInfo.KEY_LOCATION, location); return this; } /** - * @return {Boolean} - */ + * @return {Grid} + */ - getUpDownAvailable() { - return this.getParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE); + getLocation() { + return this.getObject(Grid, ModuleInfo.KEY_LOCATION); } /** - * @param {Boolean} imageSupported - * @return {SoftButtonCapabilities} - */ + * @param {Grid} area - Service area of a module. + * @return {ModuleInfo} + */ - setImageSupported(imageSupported) { - this.setParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED, imageSupported); + setServiceArea(area) { + this.validateType(Grid, area); + this.setParameter(ModuleInfo.KEY_SERVICE_AREA, area); return this; } /** - * @return {Boolean} - */ + * @return {Grid} + */ - getImageSupported() { - return this.getParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED); + getServiceArea() { + return this.getObject(Grid, ModuleInfo.KEY_SERVICE_AREA); } /** - * @param {Boolean} textSupported - * @return {SoftButtonCapabilities} - */ + * @param {Boolean} access - allow multiple users/apps to access the module or not + * @return {ModuleInfo} + */ - setTextSupported(textSupported) { - this.setParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED, textSupported); + setAllowMultipleAccess(access) { + this.setParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS, access); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ - getTextSupported() { - return this.getParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED); + getAllowMultipleAccess() { + return this.getParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS); } } - SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable'; - SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable'; - SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable'; - SoftButtonCapabilities.KEY_IMAGE_SUPPORTED = 'imageSupported'; - SoftButtonCapabilities.KEY_TEXT_SUPPORTED = 'textSupported'; + ModuleInfo.KEY_MODULE_ID = 'moduleId'; + ModuleInfo.KEY_LOCATION = 'location'; + ModuleInfo.KEY_SERVICE_AREA = 'serviceArea'; + ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS = 'allowMultipleAccess'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Contains information about a button's capabilities. + */ - class PresetBankCapabilities extends RpcStruct { + class ButtonCapabilities extends RpcStruct { + /** + * @constructor + */ constructor(parameters) { super(parameters); } /** - * @param {Boolean} onScreenPresetsAvailable - * @return {PresetBankCapabilities} - */ + * @param {ButtonName} name - The name of the button. See ButtonName. + * @return {ButtonCapabilities} + */ - setOnScreenPresetsAvailable(onScreenPresetsAvailable) { - this.setParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE, onScreenPresetsAvailable); + setName(name) { + this.validateType(ButtonName, name); + this.setParameter(ButtonCapabilities.KEY_NAME, name); return this; } /** - * @return {Boolean} - */ - - - getOnScreenPresetsAvailable() { - return this.getParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE); - } - - } - - PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE = 'onScreenPresetsAvailable'; + * @return {ButtonName} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class VehicleType extends RpcStruct { - constructor(parameters) { - super(parameters); + getName() { + return this.getObject(ButtonName, ButtonCapabilities.KEY_NAME); } /** - * @param {String} make - * @return {VehicleType} - */ + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {ButtonCapabilities} + */ - setMake(make) { - this.setParameter(VehicleType.KEY_MAKE, make); + setModuleInfo(info) { + this.validateType(ModuleInfo, info); + this.setParameter(ButtonCapabilities.KEY_MODULE_INFO, info); return this; } /** - * @return {String} - */ + * @return {ModuleInfo} + */ - getMake() { - return this.getParameter(VehicleType.KEY_MAKE); + getModuleInfo() { + return this.getObject(ModuleInfo, ButtonCapabilities.KEY_MODULE_INFO); } /** - * @param {String} model - * @return {VehicleType} - */ + * @param {Boolean} available - The button supports a short press. Whenever the button is pressed short, + * onButtonPressed( SHORT) will be invoked. + * @return {ButtonCapabilities} + */ - setModel(model) { - this.setParameter(VehicleType.KEY_MODEL, model); + setShortPressAvailable(available) { + this.setParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, available); return this; } /** - * @return {String} - */ + * @return {Boolean} + */ - getModel() { - return this.getParameter(VehicleType.KEY_MODEL); + getShortPressAvailable() { + return this.getParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE); } /** - * @param {String} modelYear - * @return {VehicleType} - */ + * @param {Boolean} available - The button supports a LONG press. Whenever the button is pressed long, + * onButtonPressed( LONG) will be invoked. + * @return {ButtonCapabilities} + */ - setModelYear(modelYear) { - this.setParameter(VehicleType.KEY_MODEL_YEAR, modelYear); + setLongPressAvailable(available) { + this.setParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, available); return this; } /** - * @return {String} - */ + * @return {Boolean} + */ - getModelYear() { - return this.getParameter(VehicleType.KEY_MODEL_YEAR); + getLongPressAvailable() { + return this.getParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE); } /** - * @param {String} trim - * @return {VehicleType} - */ + * @param {Boolean} available - The button supports "button down" and "button up". Whenever the button is pressed, + * onButtonEvent( DOWN) will be invoked. Whenever the button is released, + * onButtonEvent( UP) will be invoked. + * @return {ButtonCapabilities} + */ - setTrim(trim) { - this.setParameter(VehicleType.KEY_TRIM, trim); + setUpDownAvailable(available) { + this.setParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE, available); return this; } /** - * @return {String} - */ + * @return {Boolean} + */ - getTrim() { - return this.getParameter(VehicleType.KEY_TRIM); + getUpDownAvailable() { + return this.getParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE); } } - VehicleType.KEY_MAKE = 'make'; - VehicleType.KEY_MODEL = 'model'; - VehicleType.KEY_MODEL_YEAR = 'modelYear'; - VehicleType.KEY_TRIM = 'trim'; + ButtonCapabilities.KEY_NAME = 'name'; + ButtonCapabilities.KEY_MODULE_INFO = 'moduleInfo'; + ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable'; + ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable'; + ButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} FileType - * @property {Object} _MAP - */ + /* eslint-disable camelcase */ - class HmiZoneCapabilities extends Enum { - constructor() { - super(); + class HMICapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @return {String} + * @param {Boolean} navigation - Availability of build in Nav. True: Available, False: Not Available + * @return {HMICapabilities} */ - static get FRONT() { - return HmiZoneCapabilities._MAP.FRONT; + setNavigation(navigation) { + this.setParameter(HMICapabilities.KEY_NAVIGATION, navigation); + return this; } /** - * @return {String} + * @return {Boolean} */ - static get BACK() { - return HmiZoneCapabilities._MAP.BACK; + getNavigation() { + return this.getParameter(HMICapabilities.KEY_NAVIGATION); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @param {Boolean} call - Availability of build in phone. True: Available, False: Not Available + * @return {HMICapabilities} + */ - static valueForKey(key) { - return HmiZoneCapabilities._valueForKey(key, HmiZoneCapabilities._MAP); + setPhoneCall(call) { + this.setParameter(HMICapabilities.KEY_PHONE_CALL, call); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @return {Boolean} + */ - static keyForValue(value) { - return HmiZoneCapabilities._keyForValue(value, HmiZoneCapabilities._MAP); + getPhoneCall() { + return this.getParameter(HMICapabilities.KEY_PHONE_CALL); } + /** + * @param {Boolean} streaming - Availability of video streaming. + * @return {HMICapabilities} + */ - } - - HmiZoneCapabilities._MAP = Object.freeze({ - 'FRONT': 'FRONT', - 'BACK': 'BACK' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} PrerecordedSpeech - * @property {Object} _MAP - */ - class PrerecordedSpeech extends Enum { - constructor() { - super(); + setVideoStreaming(streaming) { + this.setParameter(HMICapabilities.KEY_VIDEO_STREAMING, streaming); + return this; } /** - * @return {String} + * @return {Boolean} */ - static get HELP_JINGLE() { - return PrerecordedSpeech._MAP.HELP_JINGLE; + getVideoStreaming() { + return this.getParameter(HMICapabilities.KEY_VIDEO_STREAMING); } /** - * @return {String} + * @param {Boolean} control - Availability of remote control feature. True: Available, False: Not Available + * @return {HMICapabilities} */ - static get INITIAL_JINGLE() { - return PrerecordedSpeech._MAP.INITIAL_JINGLE; + setRemoteControl(control) { + this.setParameter(HMICapabilities.KEY_REMOTE_CONTROL, control); + return this; } /** - * @return {String} + * @return {Boolean} */ - static get LISTEN_JINGLE() { - return PrerecordedSpeech._MAP.LISTEN_JINGLE; + getRemoteControl() { + return this.getParameter(HMICapabilities.KEY_REMOTE_CONTROL); } /** - * @return {String} + * @param {Boolean} services - Availability of App Services functionality. True: Available, False: Not Available + * @return {HMICapabilities} */ - static get POSITIVE_JINGLE() { - return PrerecordedSpeech._MAP.POSITIVE_JINGLE; + setAppServices(services) { + this.setParameter(HMICapabilities.KEY_APP_SERVICES, services); + return this; } /** - * @return {String} + * @return {Boolean} */ - static get NEGATIVE_JINGLE() { - return PrerecordedSpeech._MAP.NEGATIVE_JINGLE; + getAppServices() { + return this.getParameter(HMICapabilities.KEY_APP_SERVICES); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @param {Boolean} displays - Availability of displays capability. True: Available, False: Not Available + * @return {HMICapabilities} + */ - static valueForKey(key) { - return PrerecordedSpeech._valueForKey(key, PrerecordedSpeech._MAP); + setDisplays(displays) { + this.setParameter(HMICapabilities.KEY_DISPLAYS, displays); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @return {Boolean} + */ - static keyForValue(value) { - return PrerecordedSpeech._keyForValue(value, PrerecordedSpeech._MAP); + getDisplays() { + return this.getParameter(HMICapabilities.KEY_DISPLAYS); + } + /** + * @param {Boolean} location - Availability of seat location feature. True: Available, False: Not Available + * @return {HMICapabilities} + */ + + + setSeatLocation(location) { + this.setParameter(HMICapabilities.KEY_SEAT_LOCATION, location); + return this; + } + /** + * @return {Boolean} + */ + + + getSeatLocation() { + return this.getParameter(HMICapabilities.KEY_SEAT_LOCATION); } } - PrerecordedSpeech._MAP = Object.freeze({ - 'HELP_JINGLE': 'HELP_JINGLE', - 'INITIAL_JINGLE': 'INITIAL_JINGLE', - 'LISTEN_JINGLE': 'LISTEN_JINGLE', - 'POSITIVE_JINGLE': 'POSITIVE_JINGLE', - 'NEGATIVE_JINGLE': 'NEGATIVE_JINGLE' - }); + HMICapabilities.KEY_NAVIGATION = 'navigation'; + HMICapabilities.KEY_PHONE_CALL = 'phoneCall'; + HMICapabilities.KEY_VIDEO_STREAMING = 'videoStreaming'; + HMICapabilities.KEY_REMOTE_CONTROL = 'remoteControl'; + HMICapabilities.KEY_APP_SERVICES = 'appServices'; + HMICapabilities.KEY_DISPLAYS = 'displays'; + HMICapabilities.KEY_SEAT_LOCATION = 'seatLocation'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} SamplingRate - * @property {Object} _MAP + * The response to registerAppInterface */ - class SamplingRate extends Enum { - constructor() { - super(); + class RegisterAppInterfaceResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.RegisterAppInterface); } /** - * @return {String} + * @param {SdlMsgVersion} version - See SyncMsgVersion + * @return {RegisterAppInterfaceResponse} */ - static get SamplingRate_8KHZ() { - return SamplingRate._MAP.SamplingRate_8KHZ; + setSdlMsgVersion(version) { + this.validateType(SdlMsgVersion, version); + this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION, version); + return this; } /** - * @return {String} + * @return {SdlMsgVersion} */ - static get SamplingRate_16KHZ() { - return SamplingRate._MAP.SamplingRate_16KHZ; + getSdlMsgVersion() { + return this.getObject(SdlMsgVersion, RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION); } /** - * @return {String} + * @param {Language} language - The currently active VR+TTS language on the module. See "Language" for options. + * @return {RegisterAppInterfaceResponse} */ - static get SamplingRate_22KHZ() { - return SamplingRate._MAP.SamplingRate_22KHZ; + setLanguage(language) { + this.validateType(Language, language); + this.setParameter(RegisterAppInterfaceResponse.KEY_LANGUAGE, language); + return this; } /** - * @return {String} + * @return {Language} */ - static get SamplingRate_44KHZ() { - return SamplingRate._MAP.SamplingRate_44KHZ; + getLanguage() { + return this.getObject(Language, RegisterAppInterfaceResponse.KEY_LANGUAGE); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @param {Language} language - The currently active display language on the module. See "Language" for options. + * @return {RegisterAppInterfaceResponse} + */ - static valueForKey(key) { - return SamplingRate._valueForKey(key, SamplingRate._MAP); + setHmiDisplayLanguage(language) { + this.validateType(Language, language); + this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE, language); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @return {Language} + */ - static keyForValue(value) { - return SamplingRate._keyForValue(value, SamplingRate._MAP); + getHmiDisplayLanguage() { + return this.getObject(Language, RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE); } + /** + * @param {DisplayCapabilities} capabilities - See DisplayCapabilities. This parameter is deprecated and replaced by + * SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} + */ - } // We have to use SamplingRate_ prefix in the name because javascript will not - // allow the enum to start with a number - - - SamplingRate._MAP = Object.freeze({ - 'SamplingRate_8KHZ': '8KHZ', - 'SamplingRate_16KHZ': '16KHZ', - 'SamplingRate_22KHZ': '22KHZ', - 'SamplingRate_44KHZ': '44KHZ' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} BitsPerSample - * @property {Object} _MAP - */ - class BitsPerSample extends Enum { - constructor() { - super(); + setDisplayCapabilities(capabilities) { + this.validateType(DisplayCapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES, capabilities); + return this; } /** - * @return {String} + * @return {DisplayCapabilities} */ - static get BitsPerSample_8_BIT() { - return BitsPerSample._MAP.BitsPerSample_8_BIT; + getDisplayCapabilities() { + return this.getObject(DisplayCapabilities, RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES); } /** - * @return {String} + * @param {ButtonCapabilities[]} capabilities - See ButtonCapabilities. This parameter is deprecated and replaced by + * SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} */ - static get BitsPerSample_16_BIT() { - return BitsPerSample._MAP.BitsPerSample_16_BIT; + setButtonCapabilities(capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES, capabilities); + return this; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @return {ButtonCapabilities[]} + */ - static valueForKey(key) { - return BitsPerSample._valueForKey(key, BitsPerSample._MAP); + getButtonCapabilities() { + return this.getObject(ButtonCapabilities, RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @param {SoftButtonCapabilities[]} capabilities - If returned, the platform supports on-screen SoftButtons; see + * SoftButtonCapabilities. This parameter is deprecated and + * replaced by SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} + */ - static keyForValue(value) { - return BitsPerSample._keyForValue(value, BitsPerSample._MAP); + setSoftButtonCapabilities(capabilities) { + this.validateType(SoftButtonCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES, capabilities); + return this; } + /** + * @return {SoftButtonCapabilities[]} + */ - } // We have to use BitsPerSample_ prefix in the name because javascript will not - // allow the enum to start with a number - - - BitsPerSample._MAP = Object.freeze({ - 'BitsPerSample_8_BIT': '8_BIT', - 'BitsPerSample_16_BIT': '16_BIT' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} AudioType - * @property {Object} _MAP - */ - class AudioType extends Enum { - constructor() { - super(); + getSoftButtonCapabilities() { + return this.getObject(SoftButtonCapabilities, RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES); } /** - * @return {String} + * @param {PresetBankCapabilities} capabilities - If returned, the platform supports custom on-screen Presets; see + * PresetBankCapabilities. This parameter is deprecated and replaced + * by SystemCapability using DISPLAYS. + * @return {RegisterAppInterfaceResponse} */ - static get PCM() { - return AudioType._MAP.PCM; + setPresetBankCapabilities(capabilities) { + this.validateType(PresetBankCapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES, capabilities); + return this; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @return {PresetBankCapabilities} + */ - static valueForKey(key) { - return AudioType._valueForKey(key, AudioType._MAP); + getPresetBankCapabilities() { + return this.getObject(PresetBankCapabilities, RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @param {HmiZoneCapabilities[]} capabilities - See HmiZoneCapabilities + * @return {RegisterAppInterfaceResponse} + */ - static keyForValue(value) { - return AudioType._keyForValue(value, AudioType._MAP); + setHmiZoneCapabilities(capabilities) { + this.validateType(HmiZoneCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES, capabilities); + return this; } + /** + * @return {HmiZoneCapabilities[]} + */ - } - - AudioType._MAP = Object.freeze({ - 'PCM': 'PCM' - }); - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class AudioPassThruCapabilities extends RpcStruct { - constructor(parameters) { - super(parameters); + getHmiZoneCapabilities() { + return this.getObject(HmiZoneCapabilities, RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES); } /** - * @param {SamplingRate} samplingRate - * @return {AudioPassThruCapabilities} - */ + * @param {SpeechCapabilities[]} capabilities - See SpeechCapabilities + * @return {RegisterAppInterfaceResponse} + */ - setSamplingRate(samplingRate) { - this.validateType(SamplingRate, samplingRate); - this.setParameter(AudioPassThruCapabilities.KEY_SAMPLING_RATE, samplingRate); + setSpeechCapabilities(capabilities) { + this.validateType(SpeechCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES, capabilities); return this; } /** - * @return {SamplingRate} - */ + * @return {SpeechCapabilities[]} + */ - getSamplingRate() { - return this.getObject(SamplingRate, AudioPassThruCapabilities.KEY_SAMPLING_RATE); + getSpeechCapabilities() { + return this.getObject(SpeechCapabilities, RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES); } /** - * @param {BitsPerSample} bitsPerSample - * @return {AudioPassThruCapabilities} - */ + * @param {PrerecordedSpeech[]} speech - See PrerecordedSpeech + * @return {RegisterAppInterfaceResponse} + */ - setBitsPerSample(bitsPerSample) { - this.validateType(BitsPerSample, bitsPerSample); - this.setParameter(AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE, bitsPerSample); + setPrerecordedSpeech(speech) { + this.validateType(PrerecordedSpeech, speech, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH, speech); return this; } /** - * @return {BitsPerSample} - */ + * @return {PrerecordedSpeech[]} + */ - getBitsPerSample() { - return this.getObject(BitsPerSample, AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE); + getPrerecordedSpeech() { + return this.getObject(PrerecordedSpeech, RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH); } /** - * @param {AudioType} bitsPerSample - * @return {AudioPassThruCapabilities} - */ + * @param {VrCapabilities[]} capabilities - See VrCapabilities + * @return {RegisterAppInterfaceResponse} + */ - setAudioType(audioType) { - this.validateType(AudioType, audioType); - this.setParameter(AudioPassThruCapabilities.KEY_AUDIO_TYPE, audioType); + setVrCapabilities(capabilities) { + this.validateType(VrCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES, capabilities); return this; } /** - * @return {AudioType} - */ + * @return {VrCapabilities[]} + */ - getAudioType() { - return this.getObject(AudioType, AudioPassThruCapabilities.KEY_AUDIO_TYPE); + getVrCapabilities() { + return this.getObject(VrCapabilities, RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES); } + /** + * @param {AudioPassThruCapabilities[]} capabilities - See AudioPassThruCapability + * @return {RegisterAppInterfaceResponse} + */ - } - - AudioPassThruCapabilities.KEY_SAMPLING_RATE = 'samplingRate'; - AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE = 'bitsPerSample'; - AudioPassThruCapabilities.KEY_AUDIO_TYPE = 'audioType'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} VrCapabilities - * @property {Object} _MAP - */ - class VrCapabilities extends Enum { - constructor() { - super(); + setAudioPassThruCapabilities(capabilities) { + this.validateType(AudioPassThruCapabilities, capabilities, true); + this.setParameter(RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES, capabilities); + return this; } /** - * @return {String} + * @return {AudioPassThruCapabilities[]} */ - static get VR_TEXT() { - return VrCapabilities._MAP.VR_TEXT; + getAudioPassThruCapabilities() { + return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @param {AudioPassThruCapabilities} capabilities - See AudioPassThruCapability + * @return {RegisterAppInterfaceResponse} + */ - static valueForKey(key) { - return VrCapabilities._valueForKey(key, VrCapabilities._MAP); + setPcmStreamCapabilities(capabilities) { + this.validateType(AudioPassThruCapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES, capabilities); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * @return {AudioPassThruCapabilities} + */ - static keyForValue(value) { - return VrCapabilities._keyForValue(value, VrCapabilities._MAP); + getPcmStreamCapabilities() { + return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES); } + /** + * @param {VehicleType} type - Specifies the vehicle's type. See VehicleType. + * @return {RegisterAppInterfaceResponse} + */ - } - VrCapabilities._MAP = Object.freeze({ - 'VR_TEXT': 'TEXT' - }); + setVehicleType(type) { + this.validateType(VehicleType, type); + this.setParameter(RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE, type); + return this; + } + /** + * @return {VehicleType} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class HMICapabilities extends RpcStruct { - constructor(parameters) { - super(parameters); + getVehicleType() { + return this.getObject(VehicleType, RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE); } /** - * @param {Boolean} navigation - * @return {HMICapabilities} - */ + * @param {Number[]} modes - Specifies the white-list of supported diagnostic modes (0x00-0xFF) capable for + * DiagnosticMessage requests. If a mode outside this list is requested, it will be + * rejected. + * @return {RegisterAppInterfaceResponse} + */ - setNavigation(navigation) { - this.setParameter(HMICapabilities.KEY_NAVIGATION, navigation); + setSupportedDiagModes(modes) { + this.setParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES, modes); return this; } /** - * @return {Boolean} - */ + * @return {Number[]} + */ - getNavigation() { - return this.getParameter(HMICapabilities.KEY_NAVIGATION); + getSupportedDiagModes() { + return this.getParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES); } /** - * @param {Boolean} phoneCall - * @return {HMICapabilities} - */ + * @param {HMICapabilities} capabilities - Specifies the HMI's capabilities. See HMICapabilities. + * @return {RegisterAppInterfaceResponse} + */ - setPhoneCall(phoneCall) { - this.setParameter(HMICapabilities.KEY_PHONE_CALL, phoneCall); + setHmiCapabilities(capabilities) { + this.validateType(HMICapabilities, capabilities); + this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES, capabilities); return this; } /** - * @return {Boolean} - */ + * @return {HMICapabilities} + */ - getPhoneCall() { - return this.getParameter(HMICapabilities.KEY_PHONE_CALL); + getHmiCapabilities() { + return this.getObject(HMICapabilities, RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES); } /** - * @param {Boolean} videoStreaming - * @return {HMICapabilities} - */ + * @param {String} version - The SmartDeviceLink version. + * @return {RegisterAppInterfaceResponse} + */ - setVideoStreaming(videoStreaming) { - this.setParameter(HMICapabilities.KEY_VIDEO_STREAMING, videoStreaming); + setSdlVersion(version) { + this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION, version); return this; } /** - * @return {Boolean} - */ + * @return {String} + */ - getVideoStreaming() { - return this.getParameter(HMICapabilities.KEY_VIDEO_STREAMING); + getSdlVersion() { + return this.getParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION); } /** - * @param {Boolean} remoteControl - * @return {HMICapabilities} - */ + * @param {String} version - The software version of the system that implements the SmartDeviceLink core. + * @return {RegisterAppInterfaceResponse} + */ - setRemoteControl(remoteControl) { - this.setParameter(HMICapabilities.KEY_REMOTE_CONTROL, remoteControl); + setSystemSoftwareVersion(version) { + this.setParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION, version); return this; } /** - * @return {Boolean} - */ + * @return {String} + */ - getRemoteControl() { - return this.getParameter(HMICapabilities.KEY_REMOTE_CONTROL); + getSystemSoftwareVersion() { + return this.getParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION); } /** - * @param {Boolean} appServices - * @return {HMICapabilities} - */ + * @param {Boolean} resumed - Existence of apps icon at system. If true, apps icon was resumed at system. If false, + * apps icon is not resumed at system + * @return {RegisterAppInterfaceResponse} + */ - setAppService(appServices) { - this.setParameter(HMICapabilities.KEY_APP_SERVICES, appServices); + setIconResumed(resumed) { + this.setParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED, resumed); return this; } /** - * @return {Boolean} - */ + * @return {Boolean} + */ - getAppService() { - return this.getParameter(HMICapabilities.KEY_APP_SERVICES); + getIconResumed() { + return this.getParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED); } + + } + + RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION = 'syncMsgVersion'; + RegisterAppInterfaceResponse.KEY_LANGUAGE = 'language'; + RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; + RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities'; + RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; + RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities'; + RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES = 'presetBankCapabilities'; + RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES = 'hmiZoneCapabilities'; + RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES = 'speechCapabilities'; + RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH = 'prerecordedSpeech'; + RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES = 'vrCapabilities'; + RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES = 'audioPassThruCapabilities'; + RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES = 'pcmStreamCapabilities'; + RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE = 'vehicleType'; + RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES = 'supportedDiagModes'; + RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES = 'hmiCapabilities'; + RegisterAppInterfaceResponse.KEY_SDL_VERSION = 'sdlVersion'; + RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION = 'systemSoftwareVersion'; + RegisterAppInterfaceResponse.KEY_ICON_RESUMED = 'iconResumed'; + + /* eslint-disable camelcase */ + /** + * Closes an interface from a mobile application. After unregisterAppInterface, no commands other than + * registerAppInterface will be accepted/executed. Will fail, if no registerAppInterface was completed successfully + * before. + */ + + class UnregisterAppInterface extends RpcRequest { /** - * @param {Boolean} displays - * @return {HMICapabilities} - */ + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnregisterAppInterface); + } + } - setDisplays(displays) { - this.setParameter(HMICapabilities.KEY_DISPLAYS, displays); - return this; + /* eslint-disable camelcase */ + + class UnregisterAppInterfaceResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnregisterAppInterface); } + + } + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} WindowType + * @property {Object} _MAP + */ + + class WindowType extends Enum { /** - * @return {Boolean} - */ + * @constructor + */ + constructor() { + super(); + } + /** + * This window type describes the main window on a display. + * @return {String} + */ - getDisplays() { - return this.getParameter(HMICapabilities.KEY_DISPLAYS); + static get MAIN() { + return WindowType._MAP.MAIN; } /** - * @param {Boolean} seatLocation - * @return {HMICapabilities} - */ + * A widget is a small window that the app can create to provide information and soft buttons for quick app + * control. + * @return {String} + */ - setSeatLocation(seatLocation) { - this.setParameter(HMICapabilities.KEY_SEAT_LOCATION, seatLocation); - return this; + static get WIDGET() { + return WindowType._MAP.WIDGET; } /** - * @return {Boolean} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - getSeatLocation() { - return this.getParameter(HMICapabilities.KEY_SEAT_LOCATION); + static valueForKey(key) { + return WindowType._valueForKey(key, WindowType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return WindowType._keyForValue(value, WindowType._MAP); } } - HMICapabilities.KEY_NAVIGATION = 'navigation'; - HMICapabilities.KEY_PHONE_CALL = 'phoneCall'; - HMICapabilities.KEY_VIDEO_STREAMING = 'videoStreaming'; - HMICapabilities.KEY_REMOTE_CONTROL = 'remoteControl'; - HMICapabilities.KEY_APP_SERVICES = 'appServices'; - HMICapabilities.KEY_DISPLAYS = 'displays'; - HMICapabilities.KEY_SEAT_LOCATION = 'seatLocation'; + WindowType._MAP = Object.freeze({ + 'MAIN': 'MAIN', + 'WIDGET': 'WIDGET' + }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Create a new window on the display with the specified window type. + */ - class RegisterAppInterfaceResponse extends RpcResponse { + class CreateWindow extends RpcRequest { + /** + * @constructor + */ constructor(store) { super(store); - this.setFunctionName(FunctionID.RegisterAppInterface); + this.setFunctionName(FunctionID.CreateWindow); } /** - * @param {SdlMsgVersion} The max RPC Spec version supported by this library - * @return {RegisterAppInterfaceResponse} - */ + * @param {Number} id - A unique ID to identify the window. The value of '0' will always be the default main window + * on the main display and should not be used in this context as it will already be created for + * the app. See PredefinedWindows enum. Creating a window with an ID that is already in use + * will be rejected with `INVALID_ID`. + * @return {CreateWindow} + */ - setSdlMsgVersion(sdlMsgVersion) { - this.validateType(SdlMsgVersion, sdlMsgVersion); - this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION, sdlMsgVersion); + setWindowID(id) { + this.setParameter(CreateWindow.KEY_WINDOW_ID, id); return this; } /** - * @return {SdlMsgVersion} - */ + * @return {Number} + */ - getSdlMsgVersion() { - return this.getObject(SdlMsgVersion, RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION); + getWindowID() { + return this.getParameter(CreateWindow.KEY_WINDOW_ID); } /** - * @param {Language} language - * @return {RegisterAppInterfaceResponse} - */ + * @param {String} name - The window name to be used by the HMI. The name of the pre-created default window will + * match the app name. Multiple apps can share the same window name except for the default + * main window. Creating a window with a name which is already in use by the app will result + * in `DUPLICATE_NAME`. + * @return {CreateWindow} + */ - setLanguage(language) { - this.validateType(Language, language); - this.setParameter(RegisterAppInterfaceResponse.KEY_LANGUAGE, language); + setWindowName(name) { + this.setParameter(CreateWindow.KEY_WINDOW_NAME, name); return this; } /** - * @return {Language} - */ + * @return {String} + */ - getLanguage() { - return this.getObject(Language, RegisterAppInterfaceResponse.KEY_LANGUAGE); + getWindowName() { + return this.getParameter(CreateWindow.KEY_WINDOW_NAME); } /** - * @param {Language} hmiDisplayLanguage - * @return {RegisterAppInterfaceResponse} - */ + * @param {WindowType} type - The type of the window to be created. Main window or widget. + * @return {CreateWindow} + */ - setHmiDisplayLanguage(hmiDisplayLanguage) { - this.validateType(Language, hmiDisplayLanguage); - this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE, hmiDisplayLanguage); + setType(type) { + this.validateType(WindowType, type); + this.setParameter(CreateWindow.KEY_TYPE, type); return this; } /** - * @return {Language} - */ + * @return {WindowType} + */ - getHmiDisplayLanguage() { - return this.getObject(Language, RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE); + getType() { + return this.getObject(WindowType, CreateWindow.KEY_TYPE); } /** - * @param {DisplayCapabilities} displayCapabilities - * @return {RegisterAppInterfaceResponse} - */ + * @param {String} type - Allows an app to create a widget related to a specific service type. As an example if a + * `MEDIA` app becomes active, this app becomes audible and is allowed to play audio. Actions + * such as skip or play/pause will be directed to this active media app. In case of widgets, + * the system can provide a single "media" widget which will act as a placeholder for the + * active media app. It is only allowed to have one window per service type. This means that + * a media app can only have a single MEDIA widget. Still the app can create widgets omitting + * this parameter. Those widgets would be available as app specific widgets that are + * permanently included in the HMI. This parameter is related to widgets only. The default + * main window, which is pre-created during app registration, will be created based on the + * HMI types specified in the app registration request. + * @return {CreateWindow} + */ - setDisplayCapabilities(displayCapabilities) { - this.validateType(DisplayCapabilities, displayCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES, displayCapabilities); + setAssociatedServiceType(type) { + this.setParameter(CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE, type); return this; } /** - * @return {DisplayCapabilities} - */ + * @return {String} + */ - getDisplayCapabilities() { - return this.getObject(DisplayCapabilities, RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES); + getAssociatedServiceType() { + return this.getParameter(CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE); } /** - * @param {Array} buttonCapabilities - * @return {RegisterAppInterfaceResponse} - */ + * @param {Number} id - Optional parameter. Specify whether the content sent to an existing window should be + * duplicated to the created window. If there isn't a window with the ID, the request will be + * rejected with `INVALID_DATA`. + * @return {CreateWindow} + */ - setButtonCapabilities(buttonCapabilities) { - // TODO make this work with arrays - // this.validateType(Language, buttonCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES, buttonCapabilities); + setDuplicateUpdatesFromWindowID(id) { + this.setParameter(CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID, id); return this; } /** - * @return {Array} - */ + * @return {Number} + */ - getButtonCapabilities() { - return this.getObject(ButtonCapabilities, RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES); + getDuplicateUpdatesFromWindowID() { + return this.getParameter(CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID); } - /** - * @param {Array} softButtonCapabilities - * @return {RegisterAppInterfaceResponse} - */ + } - setSoftButtonCapabilities(softButtonCapabilities) { - // TODO make this work with arrays - // this.validateType(SoftButtonCapabilities, softButtonCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES, softButtonCapabilities); - return this; - } - /** - * @return {Array} - */ + CreateWindow.KEY_WINDOW_ID = 'windowID'; + CreateWindow.KEY_WINDOW_NAME = 'windowName'; + CreateWindow.KEY_TYPE = 'type'; + CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE = 'associatedServiceType'; + CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID = 'duplicateUpdatesFromWindowID'; + /* eslint-disable camelcase */ - getSoftButtonCapabilities() { - return this.getObject(SoftButtonCapabilities, RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES); - } + class CreateWindowResponse extends RpcResponse { /** - * @param {PresetBankCapabilities} presetBankCapabilities - * @return {RegisterAppInterfaceResponse} - */ - - - setPresetBankCapabilities(presetBankCapabilities) { - this.validateType(PresetBankCapabilities, presetBankCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES, presetBankCapabilities); - return this; + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.CreateWindow); } - /** - * @return {PresetBankCapabilities} - */ + } - getPresetBankCapabilities() { - return this.getObject(PresetBankCapabilities, RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES); + /* eslint-disable camelcase */ + /** + * Deletes previously created window of the SDL application. + */ + + class DeleteWindow extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteWindow); } /** - * @param {Array} hmiZoneCapabilities - * @return {RegisterAppInterfaceResponse} - */ + * @param {Number} id - A unique ID to identify the window. The value of '0' will always be the default main window + * on the main display and cannot be deleted. See PredefinedWindows enum. + * @return {DeleteWindow} + */ - setHmiZoneCapabilities(hmiZoneCapabilities) { - // TODO make this work for arrays - // this.validateType(HmiZoneCapabilities, hmiZoneCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES, hmiZoneCapabilities); + setWindowID(id) { + this.setParameter(DeleteWindow.KEY_WINDOW_ID, id); return this; } /** - * @return {Array} - */ + * @return {Number} + */ - getHmiZoneCapabilities() { - return this.getObject(HmiZoneCapabilities, RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES); + getWindowID() { + return this.getParameter(DeleteWindow.KEY_WINDOW_ID); } - /** - * @param {Array} speechCapabilities - * @return {RegisterAppInterfaceResponse} - */ + } - setSpeechCapabilities(speechCapabilities) { - // TODO make this work for arrays - // this.validateType(SpeechCapabilities, speechCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES, speechCapabilities); - return this; - } - /** - * @return {Array} - */ + DeleteWindow.KEY_WINDOW_ID = 'windowID'; + /* eslint-disable camelcase */ - getSpeechCapabilities() { - return this.getObject(SpeechCapabilities, RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES); - } + class DeleteWindowResponse extends RpcResponse { /** - * @param {Array} speechCapabilities - * @return {RegisterAppInterfaceResponse} - */ + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteWindow); + } + } - setPrerecordedSpeech(speechCapabilities) { - // TODO make this work for arrays - // this.validateType(PrerecordedSpeech, speechCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH, speechCapabilities); - return this; + /* eslint-disable camelcase */ + /** + * Contains information about the type of image. + * @typedef {Enum} ImageType + * @property {Object} _MAP + */ + + class ImageType extends Enum { + /** + * @constructor + */ + constructor() { + super(); } /** - * @return {Array} - */ + * @return {String} + */ - getPrerecordedSpeech() { - return this.getObject(PrerecordedSpeech, RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH); + static get STATIC() { + return ImageType._MAP.STATIC; } /** - * @param {Array} vrCapabilities - * @return {RegisterAppInterfaceResponse} - */ + * @return {String} + */ - setVrCapabilities(vrCapabilities) { - // TODO make this work for arrays - // this.validateType(VrCapabilities, vrCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES, vrCapabilities); - return this; + static get DYNAMIC() { + return ImageType._MAP.DYNAMIC; } /** - * @return {Array} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - getVrCapabilities() { - return this.getObject(VrCapabilities, RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES); + static valueForKey(key) { + return ImageType._valueForKey(key, ImageType._MAP); } /** - * @param {Array} audioPassThruCapabilities - * @return {RegisterAppInterfaceResponse} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - setAudioPassThruCapabilities(audioPassThruCapabilities) { - // TODO make this work for arrays - // this.validateType(AudioPassThruCapabilities, audioPassThruCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES, audioPassThruCapabilities); - return this; + static keyForValue(value) { + return ImageType._keyForValue(value, ImageType._MAP); } - /** - * @return {Array} - */ + } - getAudioPassThruCapabilities() { - return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES); + ImageType._MAP = Object.freeze({ + 'STATIC': 'STATIC', + 'DYNAMIC': 'DYNAMIC' + }); + + /* eslint-disable camelcase */ + + class Image extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @param {AudioPassThruCapabilities} pcmStreamCapabilities - * @return {RegisterAppInterfaceResponse} - */ + * @param {String} value - Either the static hex icon value or the binary image file name identifier (sent by + * PutFile). + * @return {Image} + */ - setPcmStreamCapabilities(pcmStreamCapabilities) { - this.validateType(AudioPassThruCapabilities, pcmStreamCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES, pcmStreamCapabilities); + setValue(value) { + this.setParameter(Image.KEY_VALUE, value); return this; } /** - * @return {AudioPassThruCapabilities} - */ + * @return {String} + */ - getPcmStreamCapabilities() { - return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES); + getValue() { + return this.getParameter(Image.KEY_VALUE); } /** - * @param {VehicleType} vehicleType - * @return {RegisterAppInterfaceResponse} - */ + * @param {ImageType} type - Describes, whether it is a static or dynamic image. + * @return {Image} + */ - setVehicleType(vehicleType) { - this.validateType(VehicleType, vehicleType); - this.setParameter(RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE, vehicleType); + setImageType(type) { + this.validateType(ImageType, type); + this.setParameter(Image.KEY_IMAGE_TYPE, type); return this; } /** - * @return {VehicleType} - */ + * @return {ImageType} + */ - getVehicleType() { - return this.getObject(VehicleType, RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE); + getImageType() { + return this.getObject(ImageType, Image.KEY_IMAGE_TYPE); } /** - * @param {Number} supportedDiagModes - * @return {RegisterAppInterfaceResponse} - */ + * @param {Boolean} template - If true, the image is a template image and can be recolored by the HMI + * @return {Image} + */ - setSupportedDiagModes(supportedDiagModes) { - this.setParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE, supportedDiagModes); + setIsTemplate(template) { + this.setParameter(Image.KEY_IS_TEMPLATE, template); return this; } /** - * @return {Number} - */ + * @return {Boolean} + */ - getSupportedDiagModes() { - return this.getParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE); + getIsTemplate() { + return this.getParameter(Image.KEY_IS_TEMPLATE); } - /** - * @param {HMICapabilities} hmiCapabilities - * @return {RegisterAppInterfaceResponse} - */ + } - setHMICapabilities(hmiCapabilities) { - this.validateType(HMICapabilities, hmiCapabilities); - this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES, hmiCapabilities); - return this; - } - /** - * @return {HMICapabilities} - */ + Image.KEY_VALUE = 'value'; + Image.KEY_IMAGE_TYPE = 'imageType'; + Image.KEY_IS_TEMPLATE = 'isTemplate'; + /* eslint-disable camelcase */ - getHMICapabilities() { - return this.getObject(HMICapabilities, RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES); + class VrHelpItem extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @param {String} sdlVersion - * @return {RegisterAppInterfaceResponse} - */ + * @param {String} text - Text to display for VR Help item + * @return {VrHelpItem} + */ - setSdlVersion(sdlVersion) { - this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION, sdlVersion); + setText(text) { + this.setParameter(VrHelpItem.KEY_TEXT, text); return this; } /** - * @return {String} - */ + * @return {String} + */ - getSdlVersion() { - return this.getParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION); + getText() { + return this.getParameter(VrHelpItem.KEY_TEXT); } /** - * @param {String} systemSoftwareVersion - * @return {RegisterAppInterfaceResponse} - */ + * @param {Image} image - Image struct for VR Help item + * @return {VrHelpItem} + */ - setSystemSoftwareVersion(systemSoftwareVersion) { - this.setParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION, systemSoftwareVersion); + setImage(image) { + this.validateType(Image, image); + this.setParameter(VrHelpItem.KEY_IMAGE, image); return this; } /** - * @return {String} - */ + * @return {Image} + */ - getSystemSoftwareVersion() { - return this.getParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION); + getImage() { + return this.getObject(Image, VrHelpItem.KEY_IMAGE); } /** - * @param {Boolean} iconResumed - * @return {RegisterAppInterfaceResponse} - */ + * @param {Number} position - Position to display item in VR Help list + * @return {VrHelpItem} + */ - setIconResumed(iconResumed) { - this.setParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED, iconResumed); + setPosition(position) { + this.setParameter(VrHelpItem.KEY_POSITION, position); return this; } /** - * @return {Boolean} - */ + * @return {Number} + */ - getIconResumed() { - return this.getParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED); + getPosition() { + return this.getParameter(VrHelpItem.KEY_POSITION); } } - RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION = 'syncMsgVersion'; - RegisterAppInterfaceResponse.KEY_LANGUAGE = 'language'; - RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; - RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities'; - RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; - RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities'; - RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES = 'presetBankCapabilities'; - RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES = 'hmiZoneCapabilities'; - RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES = 'speechCapabilities'; - RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH = 'prerecordedSpeech'; - RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES = 'vrCapabilities'; - RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES = 'audioPassThruCapabilities'; - RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES = 'pcmStreamCapabilities'; - RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE = 'vehicleType'; - RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE = 'supportedDiagModes'; - RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES = 'hmiCapabilities'; - RegisterAppInterfaceResponse.KEY_SDL_VERSION = 'sdlVersion'; - RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION = 'systemSoftwareVersion'; - RegisterAppInterfaceResponse.KEY_ICON_RESUMED = 'iconResumed'; + VrHelpItem.KEY_TEXT = 'text'; + VrHelpItem.KEY_IMAGE = 'image'; + VrHelpItem.KEY_POSITION = 'position'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Describes the location of a seat. + */ - class SetAppIcon extends RpcRequest { + class SeatLocation extends RpcStruct { /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.SetAppIcon); + * @constructor + */ + constructor(parameters) { + super(parameters); } /** - * @param {String} fileName - * @return {SetAppIcon} - */ + * @param {Grid} grid - Describes a location (origin coordinates and span) of a vehicle component. + * @return {SeatLocation} + */ - setFileName(fileName) { - this.setParameter(SetAppIcon.KEY_FILE_NAME, fileName); + setGrid(grid) { + this.validateType(Grid, grid); + this.setParameter(SeatLocation.KEY_GRID, grid); return this; } /** - * @return {String} - */ + * @return {Grid} + */ - getFileName() { - return this.getParameter(SetAppIcon.KEY_FILE_NAME); + getGrid() { + return this.getObject(Grid, SeatLocation.KEY_GRID); } } - SetAppIcon.KEY_FILE_NAME = 'syncFileName'; - - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - class SetAppIconResponse extends RpcResponse { - /** - * @constructor - */ - constructor(store) { - super(store); - this.setFunctionName(FunctionID.SetAppIcon); - } - - } + SeatLocation.KEY_GRID = 'grid'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} SoftButtonType + * How the main menu or submenu is laid out on screen + * @typedef {Enum} MenuLayout * @property {Object} _MAP */ - class SoftButtonType extends Enum { + class MenuLayout extends Enum { + /** + * @constructor + */ constructor() { super(); } @@ -23547,1664 +21823,20305 @@ */ - static get SBT_TEXT() { - return SoftButtonType._MAP.SBT_TEXT; + static get LIST() { + return MenuLayout._MAP.LIST; } /** * @return {String} */ - static get SBT_IMAGE() { - return SoftButtonType._MAP.SBT_IMAGE; + static get TILES() { + return MenuLayout._MAP.TILES; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return MenuLayout._valueForKey(key, MenuLayout._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return MenuLayout._keyForValue(value, MenuLayout._MAP); + } + + } + + MenuLayout._MAP = Object.freeze({ + 'LIST': 'LIST', + 'TILES': 'TILES' + }); + + /* eslint-disable camelcase */ + /** + * Enumeration listing possible keyboard layouts. + * @typedef {Enum} KeyboardLayout + * @property {Object} _MAP + */ + + class KeyboardLayout extends Enum { + /** + * @constructor + */ + constructor() { + super(); } /** * @return {String} */ - static get SBT_BOTH() { - return SoftButtonType._MAP.SBT_BOTH; + static get QWERTY() { + return KeyboardLayout._MAP.QWERTY; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @return {String} + */ + + + static get QWERTZ() { + return KeyboardLayout._MAP.QWERTZ; + } + /** + * @return {String} + */ + + + static get AZERTY() { + return KeyboardLayout._MAP.AZERTY; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { - return SoftButtonType._valueForKey(key, SoftButtonType._MAP); + return KeyboardLayout._valueForKey(key, KeyboardLayout._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return SoftButtonType._keyForValue(value, SoftButtonType._MAP); + return KeyboardLayout._keyForValue(value, KeyboardLayout._MAP); } } - SoftButtonType._MAP = Object.freeze({ - 'SBT_TEXT': 'TEXT', - 'SBT_IMAGE': 'IMAGE', - 'SBT_BOTH': 'BOTH' + KeyboardLayout._MAP = Object.freeze({ + 'QWERTY': 'QWERTY', + 'QWERTZ': 'QWERTZ', + 'AZERTY': 'AZERTY' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} SystemAction + * Enumeration listing possible keyboard events. + * @typedef {Enum} KeypressMode * @property {Object} _MAP */ - class SystemAction extends Enum { + class KeypressMode extends Enum { + /** + * @constructor + */ constructor() { super(); } /** + * Each keypress is individually sent as the user presses the keyboard keys. * @return {String} */ - static get DEFAULT_ACTION() { - return SystemAction._MAP.DEFAULT_ACTION; + static get SINGLE_KEYPRESS() { + return KeypressMode._MAP.SINGLE_KEYPRESS; } /** + * The keypresses are queued and a string is eventually sent once the user chooses to submit their entry. * @return {String} */ - static get STEAL_FOCUS() { - return SystemAction._MAP.STEAL_FOCUS; + static get QUEUE_KEYPRESSES() { + return KeypressMode._MAP.QUEUE_KEYPRESSES; } /** + * The keypresses are queue and a string is sent each time the user presses a keyboard key; the string contains + * the entire current entry. * @return {String} */ - static get KEEP_CONTEXT() { - return SystemAction._MAP.KEEP_CONTEXT; + static get RESEND_CURRENT_ENTRY() { + return KeypressMode._MAP.RESEND_CURRENT_ENTRY; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { - return SystemAction._valueForKey(key, SystemAction._MAP); + return KeypressMode._valueForKey(key, KeypressMode._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return SystemAction._keyForValue(value, SystemAction._MAP); + return KeypressMode._keyForValue(value, KeypressMode._MAP); } } - SystemAction._MAP = Object.freeze({ - 'DEFAULT_ACTION': 'DEFAULT_ACTION', - 'STEAL_FOCUS': 'STEAL_FOCUS', - 'KEEP_CONTEXT': 'KEEP_CONTEXT' + KeypressMode._MAP = Object.freeze({ + 'SINGLE_KEYPRESS': 'SINGLE_KEYPRESS', + 'QUEUE_KEYPRESSES': 'QUEUE_KEYPRESSES', + 'RESEND_CURRENT_ENTRY': 'RESEND_CURRENT_ENTRY' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Configuration of on-screen keyboard (if available). + */ - class SoftButton extends RpcStruct { + class KeyboardProperties extends RpcStruct { + /** + * @constructor + */ constructor(parameters) { super(parameters); } /** - * @param {SoftButtonType} type - * @return {SoftButton} - */ + * @param {Language} language - The keyboard language. + * @return {KeyboardProperties} + */ - setType(type) { - this.validateType(SoftButtonType, type); - this.setParameter(SoftButton.KEY_TYPE, type); + setLanguage(language) { + this.validateType(Language, language); + this.setParameter(KeyboardProperties.KEY_LANGUAGE, language); return this; } /** - * @return {SoftButtonType} - */ + * @return {Language} + */ - getType() { - return this.getObject(SoftButtonType, SoftButton.KEY_TYPE); + getLanguage() { + return this.getObject(Language, KeyboardProperties.KEY_LANGUAGE); } /** - * @param {String} text - * @return {SoftButton} - */ + * @param {KeyboardLayout} layout - Desired keyboard layout. + * @return {KeyboardProperties} + */ - setText(text) { - this.setParameter(SoftButton.KEY_TEXT, text); + setKeyboardLayout(layout) { + this.validateType(KeyboardLayout, layout); + this.setParameter(KeyboardProperties.KEY_KEYBOARD_LAYOUT, layout); return this; } /** - * @return {String} - */ + * @return {KeyboardLayout} + */ - getText() { - return this.getParameter(SoftButton.KEY_TEXT); + getKeyboardLayout() { + return this.getObject(KeyboardLayout, KeyboardProperties.KEY_KEYBOARD_LAYOUT); } /** - * @param {Image} image - * @return {SoftButton} - */ + * @param {KeypressMode} mode - Desired keypress mode. If omitted, this value will be set to RESEND_CURRENT_ENTRY. + * @return {KeyboardProperties} + */ - setImage(image) { - this.validateType(Image, image); - this.setParameter(SoftButton.KEY_IMAGE, image); + setKeypressMode(mode) { + this.validateType(KeypressMode, mode); + this.setParameter(KeyboardProperties.KEY_KEYPRESS_MODE, mode); return this; } /** - * @return {Image} - */ + * @return {KeypressMode} + */ - getImage() { - return this.getObject(Image, SoftButton.KEY_IMAGE); + getKeypressMode() { + return this.getObject(KeypressMode, KeyboardProperties.KEY_KEYPRESS_MODE); } /** - * @param {Boolean} isHighlighted - * @return {SoftButton} - */ + * @param {String[]} list - Array of keyboard characters to enable. All omitted characters will be greyed out + * (disabled) on the keyboard. If omitted, the entire keyboard will be enabled. + * @return {KeyboardProperties} + */ - setIsHighlighted(isHighlighted) { - this.setParameter(SoftButton.KEY_IS_HIGHLIGHTED, isHighlighted); + setLimitedCharacterList(list) { + this.setParameter(KeyboardProperties.KEY_LIMITED_CHARACTER_LIST, list); return this; } /** - * @return {Boolean} - */ + * @return {String[]} + */ - getIsHighlighted() { - return this.getParameter(SoftButton.KEY_IS_HIGHLIGHTED); + getLimitedCharacterList() { + return this.getParameter(KeyboardProperties.KEY_LIMITED_CHARACTER_LIST); } /** - * @param {Number} softButtonID - * @return {SoftButton} - */ + * @param {String} text - Deprecated, use autoCompleteList instead. + * @return {KeyboardProperties} + */ - setSoftButtonID(softButtonID) { - this.setParameter(SoftButton.KEY_SOFT_BUTTON_ID, softButtonID); + setAutoCompleteText(text) { + this.setParameter(KeyboardProperties.KEY_AUTO_COMPLETE_TEXT, text); return this; } /** - * @return {Number} - */ + * @return {String} + */ - getSoftButtonID() { - return this.getParameter(SoftButton.KEY_SOFT_BUTTON_ID); + getAutoCompleteText() { + return this.getParameter(KeyboardProperties.KEY_AUTO_COMPLETE_TEXT); } /** - * @param {SystemAction} systemAction - * @return {SoftButton} - */ + * @param {String[]} list - Allows an app to prepopulate the text field with a list of suggested or completed + * entries as the user types. If empty, the auto-complete list will be removed from the + * screen. + * @return {KeyboardProperties} + */ - setSystemAction(systemAction) { - this.validateType(SystemAction, systemAction); - this.setParameter(SoftButton.KEY_SYSTEM_ACTION, systemAction); + setAutoCompleteList(list) { + this.setParameter(KeyboardProperties.KEY_AUTO_COMPLETE_LIST, list); return this; } /** - * @return {SystemAction} - */ + * @return {String[]} + */ - getSystemAction() { - return this.getObject(SystemAction, SoftButton.KEY_SYSTEM_ACTION); + getAutoCompleteList() { + return this.getParameter(KeyboardProperties.KEY_AUTO_COMPLETE_LIST); } } - SoftButton.KEY_TYPE = 'type'; - SoftButton.KEY_TEXT = 'text'; - SoftButton.KEY_IMAGE = 'image'; - SoftButton.KEY_IS_HIGHLIGHTED = 'isHighlighted'; - SoftButton.KEY_SOFT_BUTTON_ID = 'softButtonID'; - SoftButton.KEY_SYSTEM_ACTION = 'systemAction'; + KeyboardProperties.KEY_LANGUAGE = 'language'; + KeyboardProperties.KEY_KEYBOARD_LAYOUT = 'keyboardLayout'; + KeyboardProperties.KEY_KEYPRESS_MODE = 'keypressMode'; + KeyboardProperties.KEY_LIMITED_CHARACTER_LIST = 'limitedCharacterList'; + KeyboardProperties.KEY_AUTO_COMPLETE_TEXT = 'autoCompleteText'; + KeyboardProperties.KEY_AUTO_COMPLETE_LIST = 'autoCompleteList'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} MetadataType - * @property {Object} _MAP + * Allows setting global properties. */ - class MetadataType extends Enum { - constructor() { - super(); + class SetGlobalProperties extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetGlobalProperties); } /** - * @return {String} + * @param {SeatLocation} location - Location of the user's seat. Default is driver's seat location if it is not set + * yet. + * @return {SetGlobalProperties} */ - static get mediaTitle() { - return MetadataType._MAP.mediaTitle; + setUserLocation(location) { + this.validateType(SeatLocation, location); + this.setParameter(SetGlobalProperties.KEY_USER_LOCATION, location); + return this; } /** - * @return {String} + * @return {SeatLocation} */ - static get mediaArtist() { - return MetadataType._MAP.mediaArtist; + getUserLocation() { + return this.getObject(SeatLocation, SetGlobalProperties.KEY_USER_LOCATION); } /** - * @return {String} + * @param {TTSChunk[]} prompt - The help prompt. An array of text chunks of type TTSChunk. See TTSChunk. The array + * must have at least one item. + * @return {SetGlobalProperties} */ - static get mediaAlbum() { - return MetadataType._MAP.mediaAlbum; + setHelpPrompt(prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(SetGlobalProperties.KEY_HELP_PROMPT, prompt); + return this; } /** - * @return {String} + * @return {TTSChunk[]} */ - static get mediaYear() { - return MetadataType._MAP.mediaYear; + getHelpPrompt() { + return this.getObject(TTSChunk, SetGlobalProperties.KEY_HELP_PROMPT); } /** - * @return {String} + * @param {TTSChunk[]} prompt - Help text for a wait timeout. An array of text chunks of type TTSChunk. See + * TTSChunk. The array must have at least one item. + * @return {SetGlobalProperties} */ - static get mediaGenre() { - return MetadataType._MAP.mediaGenre; + setTimeoutPrompt(prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(SetGlobalProperties.KEY_TIMEOUT_PROMPT, prompt); + return this; } /** - * @return {String} + * @return {TTSChunk[]} */ - static get mediaStation() { - return MetadataType._MAP.mediaStation; + getTimeoutPrompt() { + return this.getObject(TTSChunk, SetGlobalProperties.KEY_TIMEOUT_PROMPT); } /** - * @return {String} + * @param {String} title - VR Help Title text. If omitted on supported displays, the default module help title shall + * be used. If omitted and one or more vrHelp items are provided, the request will be + * rejected. + * @return {SetGlobalProperties} */ - static get rating() { - return MetadataType._MAP.rating; + setVrHelpTitle(title) { + this.setParameter(SetGlobalProperties.KEY_VR_HELP_TITLE, title); + return this; } /** * @return {String} */ - static get currentTemperature() { - return MetadataType._MAP.currentTemperature; + getVrHelpTitle() { + return this.getParameter(SetGlobalProperties.KEY_VR_HELP_TITLE); } /** - * @return {String} + * @param {VrHelpItem[]} help - VR Help Items. If omitted on supported displays, the default SmartDeviceLink VR help + * / What Can I Say? screen shall be used. If the list of VR Help Items contains + * nonsequential positions (e.g. [1,2,4]), the RPC shall be rejected. If omitted and a + * vrHelpTitle is provided, the request will be rejected. + * @return {SetGlobalProperties} */ - static get maximumTemperature() { - return MetadataType._MAP.maximumTemperature; + setVrHelp(help) { + this.validateType(VrHelpItem, help, true); + this.setParameter(SetGlobalProperties.KEY_VR_HELP, help); + return this; } /** - * @return {String} + * @return {VrHelpItem[]} */ - static get minimumTemperature() { - return MetadataType._MAP.minimumTemperature; + getVrHelp() { + return this.getObject(VrHelpItem, SetGlobalProperties.KEY_VR_HELP); } /** - * @return {String} + * @param {String} title - Optional text to label an app menu button (for certain touchscreen platforms). + * @return {SetGlobalProperties} */ - static get weatherTerm() { - return MetadataType._MAP.weatherTerm; + setMenuTitle(title) { + this.setParameter(SetGlobalProperties.KEY_MENU_TITLE, title); + return this; } /** * @return {String} */ - static get humidity() { - return MetadataType._MAP.humidity; + getMenuTitle() { + return this.getParameter(SetGlobalProperties.KEY_MENU_TITLE); } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * @param {Image} icon - Optional icon to draw on an app menu button (for certain touchscreen platforms). + * @return {SetGlobalProperties} + */ - static valueForKey(key) { - return MetadataType._valueForKey(key, MetadataType._MAP); + setMenuIcon(icon) { + this.validateType(Image, icon); + this.setParameter(SetGlobalProperties.KEY_MENU_ICON, icon); + return this; } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ - - - static keyForValue(value) { - return MetadataType._keyForValue(value, MetadataType._MAP); - } - - } - - MetadataType._MAP = Object.freeze({ - 'mediaTitle': 'mediaTitle', - 'mediaArtist': 'mediaArtist', - 'mediaAlbum': 'mediaAlbum', - 'mediaYear': 'mediaYear', - 'mediaGenre': 'mediaGenre', - 'mediaStation': 'mediaStation', - 'rating': 'rating', - 'currentTemperature': 'currentTemperature', - 'maximumTemperature': 'maximumTemperature', - 'minimumTemperature': 'minimumTemperature', - 'weatherTerm': 'weatherTerm', - 'humidity': 'humidity' - }); + * @return {Image} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class MetadataTags extends RpcStruct { - /** - * @constructor - */ - constructor(parameters) { - super(parameters); + getMenuIcon() { + return this.getObject(Image, SetGlobalProperties.KEY_MENU_ICON); } /** - * @param {Array} mainField1 - * @return {MetadataTags} - */ + * @param {KeyboardProperties} properties - On-screen keyboard configuration (if available). + * @return {SetGlobalProperties} + */ - setMainField1(mainField1) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_1, mainField1); + setKeyboardProperties(properties) { + this.validateType(KeyboardProperties, properties); + this.setParameter(SetGlobalProperties.KEY_KEYBOARD_PROPERTIES, properties); return this; } /** - * @return {Array} - */ + * @return {KeyboardProperties} + */ - getMainField1() { - return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_1); + getKeyboardProperties() { + return this.getObject(KeyboardProperties, SetGlobalProperties.KEY_KEYBOARD_PROPERTIES); } /** - * @param {Array} mainField2 - * @return {MetadataTags} - */ + * @param {MenuLayout} layout - Sets the layout of the main menu screen. If this is sent while a menu is already on- + * screen, the head unit will change the display to the new layout type. + * @return {SetGlobalProperties} + */ - setMainField2(mainField2) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_2, mainField2); + setMenuLayout(layout) { + this.validateType(MenuLayout, layout); + this.setParameter(SetGlobalProperties.KEY_MENU_LAYOUT, layout); return this; } /** - * @return {Array} - */ + * @return {MenuLayout} + */ - getMainField2() { - return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_2); + getMenuLayout() { + return this.getObject(MenuLayout, SetGlobalProperties.KEY_MENU_LAYOUT); } + + } + + SetGlobalProperties.KEY_USER_LOCATION = 'userLocation'; + SetGlobalProperties.KEY_HELP_PROMPT = 'helpPrompt'; + SetGlobalProperties.KEY_TIMEOUT_PROMPT = 'timeoutPrompt'; + SetGlobalProperties.KEY_VR_HELP_TITLE = 'vrHelpTitle'; + SetGlobalProperties.KEY_VR_HELP = 'vrHelp'; + SetGlobalProperties.KEY_MENU_TITLE = 'menuTitle'; + SetGlobalProperties.KEY_MENU_ICON = 'menuIcon'; + SetGlobalProperties.KEY_KEYBOARD_PROPERTIES = 'keyboardProperties'; + SetGlobalProperties.KEY_MENU_LAYOUT = 'menuLayout'; + + /* eslint-disable camelcase */ + + class SetGlobalPropertiesResponse extends RpcResponse { /** - * @param {Array} mainField3 - * @return {MetadataTags} - */ + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetGlobalProperties); + } + } - setMainField3(mainField3) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_3, mainField3); - return this; + /* eslint-disable camelcase */ + /** + * The different global properties. + * @typedef {Enum} GlobalProperty + * @property {Object} _MAP + */ + + class GlobalProperty extends Enum { + /** + * @constructor + */ + constructor() { + super(); } /** - * @return {Array} - */ + * Location of the user's seat of setGlobalProperties + * @return {String} + */ - getMainField3() { - return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_3); + static get USER_LOCATION() { + return GlobalProperty._MAP.USER_LOCATION; } /** - * @param {Array} mainField4 - * @return {MetadataTags} - */ + * The property helpPrompt of setGlobalProperties + * @return {String} + */ - setMainField4(mainField4) { - this.setParameter(MetadataTags.KEY_MAIN_FIELD_4, mainField4); - return this; + static get HELPPROMPT() { + return GlobalProperty._MAP.HELPPROMPT; } /** - * @return {Array} - */ + * The property timeoutPrompt of setGlobalProperties + * @return {String} + */ - getMainField4() { - return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_4); + static get TIMEOUTPROMPT() { + return GlobalProperty._MAP.TIMEOUTPROMPT; } + /** + * The property vrHelpTitle of setGlobalProperties + * @return {String} + */ - } - MetadataTags.KEY_MAIN_FIELD_1 = 'mainField1'; - MetadataTags.KEY_MAIN_FIELD_2 = 'mainField2'; - MetadataTags.KEY_MAIN_FIELD_3 = 'mainField3'; - MetadataTags.KEY_MAIN_FIELD_4 = 'mainField4'; + static get VRHELPTITLE() { + return GlobalProperty._MAP.VRHELPTITLE; + } + /** + * The property array of vrHelp of setGlobalProperties + * @return {String} + */ - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - /** - * @typedef {Enum} TextAlignment - * @property {Object} _MAP - */ - class TextAlignment extends Enum { - constructor() { - super(); + static get VRHELPITEMS() { + return GlobalProperty._MAP.VRHELPITEMS; } /** - * @return {String} - */ + * The property in-app menu name of setGlobalProperties + * @return {String} + */ - static get LEFT_ALIGNED() { - return TextAlignment._MAP.LEFT_ALIGNED; + static get MENUNAME() { + return GlobalProperty._MAP.MENUNAME; } /** - * @return {String} - */ + * The property in-app menu icon of setGlobalProperties + * @return {String} + */ - static get RIGHT_ALIGNED() { - return TextAlignment._MAP.RIGHT_ALIGNED; + static get MENUICON() { + return GlobalProperty._MAP.MENUICON; } /** - * @return {String} - */ + * The on-screen keyboard configuration of setGlobalProperties + * @return {String} + */ - static get CENTERED() { - return TextAlignment._MAP.CENTERED; + static get KEYBOARDPROPERTIES() { + return GlobalProperty._MAP.KEYBOARDPROPERTIES; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { - return TextAlignment._valueForKey(key, TextAlignment._MAP); + return GlobalProperty._valueForKey(key, GlobalProperty._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return TextAlignment._keyForValue(value, TextAlignment._MAP); + return GlobalProperty._keyForValue(value, GlobalProperty._MAP); } } - TextAlignment._MAP = Object.freeze({ - 'LEFT_ALIGNED': 'LEFT_ALIGNED', - 'RIGHT_ALIGNED': 'RIGHT_ALIGNED', - 'CENTERED': 'CENTERED' + GlobalProperty._MAP = Object.freeze({ + 'USER_LOCATION': 'USER_LOCATION', + 'HELPPROMPT': 'HELPPROMPT', + 'TIMEOUTPROMPT': 'TIMEOUTPROMPT', + 'VRHELPTITLE': 'VRHELPTITLE', + 'VRHELPITEMS': 'VRHELPITEMS', + 'MENUNAME': 'MENUNAME', + 'MENUICON': 'MENUICON', + 'KEYBOARDPROPERTIES': 'KEYBOARDPROPERTIES' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Allows resetting global properties. + */ - class Show extends RpcRequest { + class ResetGlobalProperties extends RpcRequest { /** - * @constructor - */ + * @constructor + */ constructor(store) { super(store); - this.setFunctionName(FunctionID.Show); + this.setFunctionName(FunctionID.ResetGlobalProperties); } /** - * @param {String} mainField1 - * @return {Show} - */ + * @param {GlobalProperty[]} properties - Contains the names of all global properties (like timeoutPrompt) that + * should be unset. Resetting means, that they have the same value as at + * start up (default) + * @return {ResetGlobalProperties} + */ - setMainField1(mainField1) { - this.setParameter(Show.KEY_MAIN_FIELD_1, mainField1); + setProperties(properties) { + this.validateType(GlobalProperty, properties, true); + this.setParameter(ResetGlobalProperties.KEY_PROPERTIES, properties); return this; } /** - * @return {String} - */ + * @return {GlobalProperty[]} + */ - getMainField1() { - return this.getParameter(Show.KEY_MAIN_FIELD_1); + getProperties() { + return this.getObject(GlobalProperty, ResetGlobalProperties.KEY_PROPERTIES); + } + + } + + ResetGlobalProperties.KEY_PROPERTIES = 'properties'; + + /* eslint-disable camelcase */ + + class ResetGlobalPropertiesResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ResetGlobalProperties); } + + } + + /* eslint-disable camelcase */ + + class MenuParams extends RpcStruct { /** - * @param {String} mainField2 - * @return {Show} - */ + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} id - unique ID of the sub menu, the command will be added to. If not provided, it will be + * provided to the top level of the in application menu. + * @return {MenuParams} + */ - setMainField2(mainField2) { - this.setParameter(Show.KEY_MAIN_FIELD_2, mainField2); + setParentID(id) { + this.setParameter(MenuParams.KEY_PARENT_ID, id); return this; } /** - * @return {String} - */ + * @return {Number} + */ - getMainField2() { - return this.getParameter(Show.KEY_MAIN_FIELD_2); + getParentID() { + return this.getParameter(MenuParams.KEY_PARENT_ID); } /** - * @param {String} mainField3 - * @return {Show} - */ + * @param {Number} position - Position within the items that are are at top level of the in application menu. 0 will + * insert at the front. 1 will insert at the second position. if position is greater or + * equal than the number of items on top level, the sub menu will be appended to the end. + * If this param was omitted the entry will be added at the end. + * @return {MenuParams} + */ - setMainField3(mainField3) { - this.setParameter(Show.KEY_MAIN_FIELD_3, mainField3); + setPosition(position) { + this.setParameter(MenuParams.KEY_POSITION, position); return this; } /** - * @return {String} - */ + * @return {Number} + */ - getMainField3() { - return this.getParameter(Show.KEY_MAIN_FIELD_3); + getPosition() { + return this.getParameter(MenuParams.KEY_POSITION); } /** - * @param {String} mainField4 - * @return {Show} - */ + * @param {String} name - Text to show in the menu for this sub menu. + * @return {MenuParams} + */ - setMainField4(mainField4) { - this.setParameter(Show.KEY_MAIN_FIELD_4, mainField4); + setMenuName(name) { + this.setParameter(MenuParams.KEY_MENU_NAME, name); return this; } /** - * @return {String} - */ + * @return {String} + */ - getMainField4() { - return this.getParameter(Show.KEY_MAIN_FIELD_4); + getMenuName() { + return this.getParameter(MenuParams.KEY_MENU_NAME); + } + + } + + MenuParams.KEY_PARENT_ID = 'parentID'; + MenuParams.KEY_POSITION = 'position'; + MenuParams.KEY_MENU_NAME = 'menuName'; + + /* eslint-disable camelcase */ + /** + * Adds a command to the in application menu. Either menuParams or vrCommands must be provided. + */ + + class AddCommand extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.AddCommand); } /** - * @param {TextAlignment} menuParams - * @return {Show} - */ + * @param {Number} id - unique ID of the command to add. + * @return {AddCommand} + */ - setAlignment(alignment) { - this.validateType(TextAlignment, alignment); - this.setParameter(Show.KEY_ALIGNMENT, alignment); + setCmdID(id) { + this.setParameter(AddCommand.KEY_CMD_ID, id); return this; } /** - * @return {TextAlignment} - */ + * @return {Number} + */ - getAlignment() { - return this.getObject(TextAlignment, Show.KEY_ALIGNMENT); + getCmdID() { + return this.getParameter(AddCommand.KEY_CMD_ID); } /** - * @param {String} statusBar - * @return {Show} - */ + * @param {MenuParams} params - Optional sub value containing menu parameters + * @return {AddCommand} + */ - setStatusBar(statusBar) { - this.setParameter(Show.KEY_STATUS_BAR, statusBar); + setMenuParams(params) { + this.validateType(MenuParams, params); + this.setParameter(AddCommand.KEY_MENU_PARAMS, params); return this; } /** - * @return {String} - */ + * @return {MenuParams} + */ - getStatusBar() { - return this.getParameter(Show.KEY_STATUS_BAR); + getMenuParams() { + return this.getObject(MenuParams, AddCommand.KEY_MENU_PARAMS); } /** - * @param {String} mediaClock - * @return {Show} - */ + * @param {String[]} commands - An array of strings to be used as VR synonyms for this command. If this array is + * provided, it may not be empty. + * @return {AddCommand} + */ - setMediaClock(mediaClock) { - this.setParameter(Show.KEY_MEDIA_CLOCK, mediaClock); + setVrCommands(commands) { + this.setParameter(AddCommand.KEY_VR_COMMANDS, commands); return this; } /** - * @return {String} - */ + * @return {String[]} + */ - getMediaClock() { - return this.getParameter(Show.KEY_MEDIA_CLOCK); + getVrCommands() { + return this.getParameter(AddCommand.KEY_VR_COMMANDS); } /** - * @param {String} mediaTrack - * @return {Show} - */ + * @param {Image} icon - Image struct determining whether static or dynamic icon. If omitted on supported displays, + * no (or the default if applicable) icon shall be displayed. + * @return {AddCommand} + */ - setMediaTrack(mediaTrack) { - this.setParameter(Show.KEY_MEDIA_TRACK, mediaTrack); + setCmdIcon(icon) { + this.validateType(Image, icon); + this.setParameter(AddCommand.KEY_CMD_ICON, icon); return this; } /** - * @return {String} - */ + * @return {Image} + */ - getMediaTrack() { - return this.getParameter(Show.KEY_MEDIA_TRACK); + getCmdIcon() { + return this.getObject(Image, AddCommand.KEY_CMD_ICON); } + + } + + AddCommand.KEY_CMD_ID = 'cmdID'; + AddCommand.KEY_MENU_PARAMS = 'menuParams'; + AddCommand.KEY_VR_COMMANDS = 'vrCommands'; + AddCommand.KEY_CMD_ICON = 'cmdIcon'; + + /* eslint-disable camelcase */ + + class AddCommandResponse extends RpcResponse { /** - * @param {Image} graphic - * @return {Show} - */ + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.AddCommand); + } + } - setGraphic(graphic) { - this.validateType(Image, graphic); - this.setParameter(Show.KEY_GRAPHIC, graphic); - return this; + /* eslint-disable camelcase */ + /** + * Deletes all commands from the in-application menu with the specified command id. + */ + + class DeleteCommand extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteCommand); } /** - * @return {Image} - */ + * @param {Number} id - ID of the command(s) to delete. + * @return {DeleteCommand} + */ - getGraphic() { - return this.getObject(Image, Show.KEY_GRAPHIC); + setCmdID(id) { + this.setParameter(DeleteCommand.KEY_CMD_ID, id); + return this; } /** - * @param {Image} secondaryGraphic - * @return {Show} - */ + * @return {Number} + */ - setSecondaryGraphic(secondaryGraphic) { - this.validateType(Image, secondaryGraphic); - this.setParameter(Show.KEY_SECONDARY_GRAPHIC, secondaryGraphic); - return this; + getCmdID() { + return this.getParameter(DeleteCommand.KEY_CMD_ID); } + + } + + DeleteCommand.KEY_CMD_ID = 'cmdID'; + + /* eslint-disable camelcase */ + + class DeleteCommandResponse extends RpcResponse { /** - * @return {Image} - */ + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteCommand); + } + } - getSecondaryGraphic() { - return this.getObject(Image, Show.KEY_SECONDARY_GRAPHIC); + /* eslint-disable camelcase */ + /** + * Adds a sub menu to the in-application menu. + */ + + class AddSubMenu extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.AddSubMenu); } /** - * @param {Array} softButtons - * @return {Show} - */ + * @param {Number} id - unique ID of the sub menu to add. + * @return {AddSubMenu} + */ - setSoftButtons(softButtons) { - // TODO make this work for arrays - // this.validateType(SoftButton, softButtons); - this.setParameter(Show.KEY_SOFT_BUTTONS, softButtons); + setMenuID(id) { + this.setParameter(AddSubMenu.KEY_MENU_ID, id); return this; } /** - * @return {Array} - */ + * @return {Number} + */ - getSoftButtons() { - return this.getObject(SoftButton, Show.KEY_SOFT_BUTTONS); + getMenuID() { + return this.getParameter(AddSubMenu.KEY_MENU_ID); } /** - * @param {Array} customPresets - * @return {Show} - */ + * @param {Number} position - Position within the items that are are at top level of the in application menu. 0 will + * insert at the front. 1 will insert at the second position. If position is greater or + * equal than the number of items on top level, the sub menu will be appended to the end. + * Position of any submenu will always be located before the return and exit options If + * this param was omitted the entry will be added at the end. + * @return {AddSubMenu} + */ - setCustomPresets(customPresets) { - this.setParameter(Show.KEY_CUSTOM_PRESETS, customPresets); + setPosition(position) { + this.setParameter(AddSubMenu.KEY_POSITION, position); return this; } /** - * @return {Array} - */ + * @return {Number} + */ - getCustomPresets() { - return this.getParameter(Show.KEY_CUSTOM_PRESETS); + getPosition() { + return this.getParameter(AddSubMenu.KEY_POSITION); } /** - * @param {MetadataTags} metadataTags - * @return {Show} - */ + * @param {String} name - Text to show in the menu for this sub menu. + * @return {AddSubMenu} + */ - setMetadataTags(metadataTags) { - this.validateType(MetadataTags, metadataTags); - this.setParameter(Show.KEY_METADATA_TAGS, metadataTags); + setMenuName(name) { + this.setParameter(AddSubMenu.KEY_MENU_NAME, name); return this; } /** - * @return {MetadataTags} - */ + * @return {String} + */ - getMetadataTags() { - return this.getObject(MetadataTags, Show.KEY_METADATA_TAGS); + getMenuName() { + return this.getParameter(AddSubMenu.KEY_MENU_NAME); } /** - * @param {String} templateTitle - * @return {Show} - */ + * @param {Image} icon - The image field for AddSubMenu + * @return {AddSubMenu} + */ - setTemplateTitle(templateTitle) { - this.setParameter(Show.KEY_TEMPLATE_TITLE, templateTitle); + setMenuIcon(icon) { + this.validateType(Image, icon); + this.setParameter(AddSubMenu.KEY_MENU_ICON, icon); return this; } /** - * @return {String} - */ + * @return {Image} + */ - getTemplateTitle() { - return this.getParameter(Show.KEY_TEMPLATE_TITLE); + getMenuIcon() { + return this.getObject(Image, AddSubMenu.KEY_MENU_ICON); } /** - * @param {Number} windowID - * @return {Show} - */ + * @param {MenuLayout} layout - Sets the layout of the submenu screen. + * @return {AddSubMenu} + */ - setWindowID(windowID) { - this.setParameter(Show.KEY_WINDOW_ID, windowID); + setMenuLayout(layout) { + this.validateType(MenuLayout, layout); + this.setParameter(AddSubMenu.KEY_MENU_LAYOUT, layout); return this; } /** - * @return {Number} - */ + * @return {MenuLayout} + */ - getWindowID() { - return this.getParameter(Show.KEY_WINDOW_ID); + getMenuLayout() { + return this.getObject(MenuLayout, AddSubMenu.KEY_MENU_LAYOUT); } } - Show.KEY_MAIN_FIELD_1 = 'mainField1'; - Show.KEY_MAIN_FIELD_2 = 'mainField2'; - Show.KEY_MAIN_FIELD_3 = 'mainField3'; - Show.KEY_MAIN_FIELD_4 = 'mainField4'; - Show.KEY_ALIGNMENT = 'alignment'; - Show.KEY_STATUS_BAR = 'statusBar'; - Show.KEY_MEDIA_CLOCK = 'mediaClock'; - Show.KEY_MEDIA_TRACK = 'mediaTrack'; - Show.KEY_GRAPHIC = 'graphic'; - Show.KEY_SECONDARY_GRAPHIC = 'secondaryGraphic'; - Show.KEY_SOFT_BUTTONS = 'softButtons'; - Show.KEY_CUSTOM_PRESETS = 'customPresets'; - Show.KEY_METADATA_TAGS = 'metadataTags'; - Show.KEY_TEMPLATE_TITLE = 'templateTitle'; - Show.KEY_WINDOW_ID = 'windowID'; + AddSubMenu.KEY_MENU_ID = 'menuID'; + AddSubMenu.KEY_POSITION = 'position'; + AddSubMenu.KEY_MENU_NAME = 'menuName'; + AddSubMenu.KEY_MENU_ICON = 'menuIcon'; + AddSubMenu.KEY_MENU_LAYOUT = 'menuLayout'; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ - class ShowResponse extends RpcResponse { + class AddSubMenuResponse extends RpcResponse { /** - * @constructor - */ + * @constructor + */ constructor(store) { super(store); - this.setFunctionName(FunctionID.Show); + this.setFunctionName(FunctionID.AddSubMenu); } } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Deletes a submenu from the in-application menu. + */ - class UnregisterAppInterface extends RpcRequest { + class DeleteSubMenu extends RpcRequest { /** - * @constructor - */ + * @constructor + */ constructor(store) { super(store); - this.setFunctionName(FunctionID.UnregisterAppInterface); + this.setFunctionName(FunctionID.DeleteSubMenu); + } + /** + * @param {Number} id - The "menuID" of the submenu to delete. (See addSubMenu.menuID) + * @return {DeleteSubMenu} + */ + + + setMenuID(id) { + this.setParameter(DeleteSubMenu.KEY_MENU_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getMenuID() { + return this.getParameter(DeleteSubMenu.KEY_MENU_ID); } } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + DeleteSubMenu.KEY_MENU_ID = 'menuID'; - class UnregisterAppInterfaceResponse extends RpcResponse { + /* eslint-disable camelcase */ + + class DeleteSubMenuResponse extends RpcResponse { /** - * @constructor - */ + * @constructor + */ constructor(store) { super(store); - this.setFunctionName(FunctionID.UnregisterAppInterface); + this.setFunctionName(FunctionID.DeleteSubMenu); } } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * Shows the built in menu view + */ - class RpcCreator { + class ShowAppMenu extends RpcRequest { /** - * Converts an SdlPacket to an RpcMessage - * @param {SdlPacket} sdlPacket - * @return {RpcMessage} + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ShowAppMenu); + } + /** + * @param {Number} id - If omitted the HMI opens the app's menu. If set to a sub-menu ID the HMI opens the + * corresponding sub-menu previously added using `AddSubMenu`. + * @return {ShowAppMenu} */ - static construct(sdlPacket) { - const payload = sdlPacket.getPayload(); - const binaryFrameHeader = BinaryFrameHeader.fromBinaryHeader(payload); - let message; - const rpcType = binaryFrameHeader.getRpcType(); - const rpcName = RpcType.keyForValue(rpcType); - const correlationId = binaryFrameHeader.getCorrelationId(); - const functionId = binaryFrameHeader.getFunctionId(); - const functionName = FunctionID.keyForValue(functionId); - const bulkData = binaryFrameHeader.getBulkData(); - const jsonData = binaryFrameHeader.getJsonData(); - const params = { - parameters: JsonRpcMarshaller.unmarshall(jsonData) - }; - switch (functionId) { - case FunctionID.AddCommand: - if (rpcType === RpcType.REQUEST) { - message = new AddCommand(params); - } else if (rpcType === RpcType.RESPONSE) { - message = new AddCommandResponse(params); - } - break; + setMenuID(id) { + this.setParameter(ShowAppMenu.KEY_MENU_ID, id); + return this; + } + /** + * @return {Number} + */ - case FunctionID.OnHMIStatus: - // TODO: should OnHMIStatus be OnHmiStatus, or the class name change to OnHMIStatus? or is this fine as is? - if (rpcType === RpcType.NOTIFICATION) { - message = new OnHmiStatus(params); - } - break; + getMenuID() { + return this.getParameter(ShowAppMenu.KEY_MENU_ID); + } - case FunctionID.OnLanguageChange: - if (rpcType === RpcType.NOTIFICATION) { - message = new OnLanguageChange(params); - } + } - break; + ShowAppMenu.KEY_MENU_ID = 'menuID'; - case FunctionID.PutFile: - if (rpcType === RpcType.REQUEST) { - message = new PutFile(params); - } else if (rpcType === RpcType.RESPONSE) { - message = new PutFileResponse(params); - } + /* eslint-disable camelcase */ - break; + class ShowAppMenuResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ShowAppMenu); + } - case FunctionID.RegisterAppInterface: - if (rpcType === RpcType.REQUEST) { - message = new RegisterAppInterface(params); - } else if (rpcType === RpcType.RESPONSE) { - message = new RegisterAppInterfaceResponse(params); - } + } - break; + /* eslint-disable camelcase */ + /** + * A choice is an option given to the user, which can be selected either by menu, or through voice recognition system. + */ - case FunctionID.SetAppIcon: - if (rpcType === RpcType.REQUEST) { - message = new SetAppIcon(params); - } else if (rpcType === RpcType.RESPONSE) { - message = new SetAppIconResponse(params); - } + class Choice extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} id + * @return {Choice} + */ - break; - case FunctionID.Show: - if (rpcType === RpcType.REQUEST) { - message = new Show(params); - } else if (rpcType === RpcType.RESPONSE) { - message = new ShowResponse(params); - } + setChoiceID(id) { + this.setParameter(Choice.KEY_CHOICE_ID, id); + return this; + } + /** + * @return {Number} + */ - break; - case FunctionID.UnregisterAppInterface: - if (rpcType === RpcType.REQUEST) { - message = new UnregisterAppInterface(params); - } else if (rpcType === RpcType.RESPONSE) { - message = new UnregisterAppInterfaceResponse(params); - } + getChoiceID() { + return this.getParameter(Choice.KEY_CHOICE_ID); + } + /** + * @param {String} name + * @return {Choice} + */ - break; - default: - message = null; - } + setMenuName(name) { + this.setParameter(Choice.KEY_MENU_NAME, name); + return this; + } + /** + * @return {String} + */ - if (message === null || message === undefined) { - // informs of missing classes - console.warn(`RpcCreator couldn't construct an RPC for the ${functionName} ${rpcName}`); - return null; - } - if (rpcType === RpcType.REQUEST || rpcType === RpcType.RESPONSE) { - message.setCorrelationId(correlationId); - } + getMenuName() { + return this.getParameter(Choice.KEY_MENU_NAME); + } + /** + * @param {String[]} commands + * @return {Choice} + */ - if (bulkData) { - message.setBulkData(bulkData); - } - return message; + setVrCommands(commands) { + this.setParameter(Choice.KEY_VR_COMMANDS, commands); + return this; + } + /** + * @return {String[]} + */ + + + getVrCommands() { + return this.getParameter(Choice.KEY_VR_COMMANDS); + } + /** + * @param {Image} image + * @return {Choice} + */ + + + setImage(image) { + this.validateType(Image, image); + this.setParameter(Choice.KEY_IMAGE, image); + return this; + } + /** + * @return {Image} + */ + + + getImage() { + return this.getObject(Image, Choice.KEY_IMAGE); + } + /** + * @param {String} text - Optional secondary text to display; e.g. address of POI in a search result entry + * @return {Choice} + */ + + + setSecondaryText(text) { + this.setParameter(Choice.KEY_SECONDARY_TEXT, text); + return this; + } + /** + * @return {String} + */ + + + getSecondaryText() { + return this.getParameter(Choice.KEY_SECONDARY_TEXT); + } + /** + * @param {String} text - Optional tertiary text to display; e.g. distance to POI for a search result entry + * @return {Choice} + */ + + + setTertiaryText(text) { + this.setParameter(Choice.KEY_TERTIARY_TEXT, text); + return this; + } + /** + * @return {String} + */ + + + getTertiaryText() { + return this.getParameter(Choice.KEY_TERTIARY_TEXT); + } + /** + * @param {Image} image - Optional secondary image struct for choice + * @return {Choice} + */ + + + setSecondaryImage(image) { + this.validateType(Image, image); + this.setParameter(Choice.KEY_SECONDARY_IMAGE, image); + return this; + } + /** + * @return {Image} + */ + + + getSecondaryImage() { + return this.getObject(Image, Choice.KEY_SECONDARY_IMAGE); } } - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + Choice.KEY_CHOICE_ID = 'choiceID'; + Choice.KEY_MENU_NAME = 'menuName'; + Choice.KEY_VR_COMMANDS = 'vrCommands'; + Choice.KEY_IMAGE = 'image'; + Choice.KEY_SECONDARY_TEXT = 'secondaryText'; + Choice.KEY_TERTIARY_TEXT = 'tertiaryText'; + Choice.KEY_SECONDARY_IMAGE = 'secondaryImage'; + + /* eslint-disable camelcase */ /** - * @typedef {Enum} VideoStreamingProtocol + * creates interaction choice set to be used later by performInteraction + */ + + class CreateInteractionChoiceSet extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.CreateInteractionChoiceSet); + } + /** + * @param {Number} id - Unique ID used for this interaction choice set. + * @return {CreateInteractionChoiceSet} + */ + + + setInteractionChoiceSetID(id) { + this.setParameter(CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getInteractionChoiceSetID() { + return this.getParameter(CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID); + } + /** + * @param {Choice[]} set - A choice is an option given to the user, which can be selected either by menu, or through + * voice recognition system. + * @return {CreateInteractionChoiceSet} + */ + + + setChoiceSet(set) { + this.validateType(Choice, set, true); + this.setParameter(CreateInteractionChoiceSet.KEY_CHOICE_SET, set); + return this; + } + /** + * @return {Choice[]} + */ + + + getChoiceSet() { + return this.getObject(Choice, CreateInteractionChoiceSet.KEY_CHOICE_SET); + } + + } + + CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID = 'interactionChoiceSetID'; + CreateInteractionChoiceSet.KEY_CHOICE_SET = 'choiceSet'; + + /* eslint-disable camelcase */ + + class CreateInteractionChoiceSetResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.CreateInteractionChoiceSet); + } + + } + + /* eslint-disable camelcase */ + /** + * For touchscreen interactions, the mode of how the choices are presented. + * @typedef {Enum} LayoutMode * @property {Object} _MAP */ - class VideoStreamingProtocol extends Enum { + class LayoutMode extends Enum { /** - * @constructor - */ + * @constructor + */ constructor() { super(); } /** + * This mode causes the interaction to display the previous set of choices as icons. * @return {String} */ - static get RAW() { - return VideoStreamingProtocol._MAP.RAW; + static get ICON_ONLY() { + return LayoutMode._MAP.ICON_ONLY; } /** + * This mode causes the interaction to display the previous set of choices as icons along with a search field in + * the HMI. * @return {String} */ - static get RTP() { - return VideoStreamingProtocol._MAP.RTP; + static get ICON_WITH_SEARCH() { + return LayoutMode._MAP.ICON_WITH_SEARCH; } /** + * This mode causes the interaction to display the previous set of choices as a list. * @return {String} */ - static get RTSP() { - return VideoStreamingProtocol._MAP.RTSP; + static get LIST_ONLY() { + return LayoutMode._MAP.LIST_ONLY; } /** + * This mode causes the interaction to display the previous set of choices as a list along with a search field in + * the HMI. * @return {String} */ - static get RTMP() { - return VideoStreamingProtocol._MAP.RTMP; + static get LIST_WITH_SEARCH() { + return LayoutMode._MAP.LIST_WITH_SEARCH; } /** + * This mode causes the interaction to immediately display a keyboard entry through the HMI. * @return {String} */ - static get WEBM() { - return VideoStreamingProtocol._MAP.WEBM; + static get KEYBOARD() { + return LayoutMode._MAP.KEYBOARD; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { - return VideoStreamingProtocol._valueForKey(key, VideoStreamingProtocol._MAP); + return LayoutMode._valueForKey(key, LayoutMode._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return VideoStreamingProtocol._keyForValue(value, VideoStreamingProtocol._MAP); + return LayoutMode._keyForValue(value, LayoutMode._MAP); } } - VideoStreamingProtocol._MAP = Object.freeze({ + LayoutMode._MAP = Object.freeze({ + 'ICON_ONLY': 'ICON_ONLY', + 'ICON_WITH_SEARCH': 'ICON_WITH_SEARCH', + 'LIST_ONLY': 'LIST_ONLY', + 'LIST_WITH_SEARCH': 'LIST_WITH_SEARCH', + 'KEYBOARD': 'KEYBOARD' + }); + + /* eslint-disable camelcase */ + /** + * For application-requested interactions, this mode indicates the method in which the user is notified and uses the + * interaction. + * @typedef {Enum} InteractionMode + * @property {Object} _MAP + */ + + class InteractionMode extends Enum { /** - * Raw stream bytes that contains no timestamp data and is the lowest supported video streaming + * @constructor + */ + constructor() { + super(); + } + /** + * This mode causes the interaction to only occur on the display, meaning the choices are provided only via the + * display. No Voice Interaction. + * @return {String} */ - 'RAW': 'RAW', + + static get MANUAL_ONLY() { + return InteractionMode._MAP.MANUAL_ONLY; + } /** - * RTP facilitates the transfer of real-time data. Information provided by this protocol include - * timestamps (for synchronization), sequence numbers (for packet loss and reordering detection) - * and the payload format which indicates the encoded format of the data. + * This mode causes the interaction to only occur using the headunits VR system. Selections are made by saying the + * command. + * @return {String} */ - 'RTP': 'RTP', + + static get VR_ONLY() { + return InteractionMode._MAP.VR_ONLY; + } /** - * The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the - * Real-time Transport Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP) for - * media stream delivery. However, some vendors implement proprietary transport protocols. + * This mode causes both a VR and display selection option for an interaction. The user will first be asked via + * Voice Interaction (if available). If this is unsuccessful, the system will switch to manual input. + * @return {String} */ - 'RTSP': 'RTSP', + + static get BOTH() { + return InteractionMode._MAP.BOTH; + } /** - * Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by - * Macromedia for streaming audio, video and data over the Internet, between a Flash player and - * a server. Macromedia is now owned by Adobe, which has released an incomplete version of the - * specification of the protocol for public use. + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found */ - 'RTMP': 'RTMP', + + static valueForKey(key) { + return InteractionMode._valueForKey(key, InteractionMode._MAP); + } /** - * The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and - * Vorbis audio streams. In 2013 it was updated to accommodate VP9 video and Opus audio. + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found */ - 'WEBM': 'WEBM' + + + static keyForValue(value) { + return InteractionMode._keyForValue(value, InteractionMode._MAP); + } + + } + + InteractionMode._MAP = Object.freeze({ + 'MANUAL_ONLY': 'MANUAL_ONLY', + 'VR_ONLY': 'VR_ONLY', + 'BOTH': 'BOTH' }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ /** - * @typedef {Enum} VideoStreamingCodec - * @property {Object} _MAP + * Triggers an interaction (e.g. "Permit GPS?" - Yes, no, Always Allow). */ - class VideoStreamingCodec extends Enum { + class PerformInteraction extends RpcRequest { /** - * @constructor - */ - constructor() { - super(); + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PerformInteraction); } /** - * @return {String} + * @param {String} text - Text to be displayed first. + * @return {PerformInteraction} */ - static get H264() { - return VideoStreamingCodec._MAP.H264; + setInitialText(text) { + this.setParameter(PerformInteraction.KEY_INITIAL_TEXT, text); + return this; } /** * @return {String} */ - static get H265() { - return VideoStreamingCodec._MAP.H265; + getInitialText() { + return this.getParameter(PerformInteraction.KEY_INITIAL_TEXT); + } + /** + * @param {TTSChunk[]} prompt - This is the initial prompt spoken to the user at the start of an interaction. An + * array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. + * @return {PerformInteraction} + */ + + + setInitialPrompt(prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformInteraction.KEY_INITIAL_PROMPT, prompt); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getInitialPrompt() { + return this.getObject(TTSChunk, PerformInteraction.KEY_INITIAL_PROMPT); + } + /** + * @param {InteractionMode} mode - See InteractionMode. + * @return {PerformInteraction} + */ + + + setInteractionMode(mode) { + this.validateType(InteractionMode, mode); + this.setParameter(PerformInteraction.KEY_INTERACTION_MODE, mode); + return this; + } + /** + * @return {InteractionMode} + */ + + + getInteractionMode() { + return this.getObject(InteractionMode, PerformInteraction.KEY_INTERACTION_MODE); + } + /** + * @param {Number[]} list - List of interaction choice set IDs to use with an interaction. + * @return {PerformInteraction} + */ + + + setInteractionChoiceSetIDList(list) { + this.setParameter(PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST, list); + return this; + } + /** + * @return {Number[]} + */ + + + getInteractionChoiceSetIDList() { + return this.getParameter(PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST); + } + /** + * @param {TTSChunk[]} prompt - Help text. This is the spoken string when a user speaks "help" when the interaction + * is occurring. An array of text chunks of type TTSChunk. See TTSChunk. The array must + * have at least one item. + * @return {PerformInteraction} + */ + + + setHelpPrompt(prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformInteraction.KEY_HELP_PROMPT, prompt); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getHelpPrompt() { + return this.getObject(TTSChunk, PerformInteraction.KEY_HELP_PROMPT); + } + /** + * @param {TTSChunk[]} prompt - Timeout text. This text is spoken when a VR interaction times out. An array of text + * chunks of type TTSChunk. See TTSChunk. The array must have at least one item. + * @return {PerformInteraction} + */ + + + setTimeoutPrompt(prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformInteraction.KEY_TIMEOUT_PROMPT, prompt); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getTimeoutPrompt() { + return this.getObject(TTSChunk, PerformInteraction.KEY_TIMEOUT_PROMPT); + } + /** + * @param {Number} timeout - Timeout in milliseconds. If omitted a standard value of 10000 milliseconds is used. + * Applies only to the menu portion of the interaction. The VR timeout will be handled by + * the platform. + * @return {PerformInteraction} + */ + + + setTimeout(timeout) { + this.setParameter(PerformInteraction.KEY_TIMEOUT, timeout); + return this; + } + /** + * @return {Number} + */ + + + getTimeout() { + return this.getParameter(PerformInteraction.KEY_TIMEOUT); + } + /** + * @param {VrHelpItem[]} help - Ability to send suggested VR Help Items to display on-screen during Perform + * Interaction. If omitted on supported displays, the default generated list of + * suggested choices shall be displayed. + * @return {PerformInteraction} + */ + + + setVrHelp(help) { + this.validateType(VrHelpItem, help, true); + this.setParameter(PerformInteraction.KEY_VR_HELP, help); + return this; + } + /** + * @return {VrHelpItem[]} + */ + + + getVrHelp() { + return this.getObject(VrHelpItem, PerformInteraction.KEY_VR_HELP); + } + /** + * @param {LayoutMode} layout - See LayoutMode. + * @return {PerformInteraction} + */ + + + setInteractionLayout(layout) { + this.validateType(LayoutMode, layout); + this.setParameter(PerformInteraction.KEY_INTERACTION_LAYOUT, layout); + return this; + } + /** + * @return {LayoutMode} + */ + + + getInteractionLayout() { + return this.getObject(LayoutMode, PerformInteraction.KEY_INTERACTION_LAYOUT); + } + /** + * @param {Number} id - An ID for this specific PerformInteraction to allow cancellation through the + * `CancelInteraction` RPC. + * @return {PerformInteraction} + */ + + + setCancelID(id) { + this.setParameter(PerformInteraction.KEY_CANCEL_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCancelID() { + return this.getParameter(PerformInteraction.KEY_CANCEL_ID); + } + + } + + PerformInteraction.KEY_INITIAL_TEXT = 'initialText'; + PerformInteraction.KEY_INITIAL_PROMPT = 'initialPrompt'; + PerformInteraction.KEY_INTERACTION_MODE = 'interactionMode'; + PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST = 'interactionChoiceSetIDList'; + PerformInteraction.KEY_HELP_PROMPT = 'helpPrompt'; + PerformInteraction.KEY_TIMEOUT_PROMPT = 'timeoutPrompt'; + PerformInteraction.KEY_TIMEOUT = 'timeout'; + PerformInteraction.KEY_VR_HELP = 'vrHelp'; + PerformInteraction.KEY_INTERACTION_LAYOUT = 'interactionLayout'; + PerformInteraction.KEY_CANCEL_ID = 'cancelID'; + + /* eslint-disable camelcase */ + /** + * Indicates the source from where the command was triggered. + * @typedef {Enum} TriggerSource + * @property {Object} _MAP + */ + + class TriggerSource extends Enum { + /** + * @constructor + */ + constructor() { + super(); } /** * @return {String} */ - static get Theora() { - return VideoStreamingCodec._MAP.Theora; + static get TS_MENU() { + return TriggerSource._MAP.TS_MENU; } /** * @return {String} */ - static get VP8() { - return VideoStreamingCodec._MAP.VP8; + static get TS_VR() { + return TriggerSource._MAP.TS_VR; } /** * @return {String} */ - static get VP9() { - return VideoStreamingCodec._MAP.VP9; + static get TS_KEYBOARD() { + return TriggerSource._MAP.TS_KEYBOARD; } /** - * Get the value for the given enum key - * @param value - A key to find in the map of the subclass - * @return {*} - Returns a value if found, or null if not found - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ static valueForKey(key) { - return VideoStreamingCodec._valueForKey(key, VideoStreamingCodec._MAP); + return TriggerSource._valueForKey(key, TriggerSource._MAP); } /** - * Get the key for the given enum value - * @param value - A primitive value to find the matching key for in the map of the subclass - * @return {*} - Returns a key if found, or null if not found - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ static keyForValue(value) { - return VideoStreamingCodec._keyForValue(value, VideoStreamingCodec._MAP); + return TriggerSource._keyForValue(value, TriggerSource._MAP); } } - VideoStreamingCodec._MAP = Object.freeze({ + TriggerSource._MAP = Object.freeze({ + 'TS_MENU': 'MENU', + 'TS_VR': 'VR', + 'TS_KEYBOARD': 'KEYBOARD' + }); + + /* eslint-disable camelcase */ + + class PerformInteractionResponse extends RpcResponse { /** - * A block-oriented motion-compensation-based video compression standard. As of 2014 it is one - * of the most commonly used formats for the recording, compression, and distribution of video - * content. + * @constructor */ - 'H264': 'H264', - + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PerformInteraction); + } /** - * High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video - * compression standard, one of several potential successors to the widely used AVC - * (H.264 or MPEG-4 Part 10). In comparison to AVC, HEVC offers about double the data - * compression ratio at the same level of video quality, or substantially improved video quality - * at the same bit rate. It supports resolutions up to 8192x4320, including 8K UHD. + * @param {Number} id - ID of the choice that was selected in response to PerformInteraction. Only is valid if + * general result is "success:true". + * @return {PerformInteractionResponse} */ - 'H265': 'H265', + + setChoiceID(id) { + this.setParameter(PerformInteractionResponse.KEY_CHOICE_ID, id); + return this; + } /** - * Theora is derived from the formerly proprietary VP3 codec, released into the public domain by - * On2 Technologies. It is broadly comparable in design and bitrate efficiency to MPEG-4 Part 2, - * early versions of Windows Media Video, and RealVideo while lacking some of the features - * present in some of these other codecs. It is comparable in open standards philosophy to the - * BBC's Dirac codec. + * @return {Number} */ - 'Theora': 'Theora', + + getChoiceID() { + return this.getParameter(PerformInteractionResponse.KEY_CHOICE_ID); + } /** - * VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and - * Opus audio. The image format WebP is based on VP8's intra-frame coding. VP8's direct - * successor, VP9, and the emerging royalty-free internet video format AV1 from the Alliance - * for Open Media (AOMedia) are based on VP8. + * @param {String} entry - Manually entered text selection, e.g. through keyboard Can be returned in lieu of + * choiceID, depending on trigger source + * @return {PerformInteractionResponse} */ - 'VP8': 'VP8', + + setManualTextEntry(entry) { + this.setParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY, entry); + return this; + } /** - * Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video - * (UHD) and also enables lossless compression. + * @return {String} */ - 'VP9': 'VP9' - }); - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - class VideoStreamingFormat extends RpcStruct { - /** - * @constructor - */ - constructor() { - super(); + getManualTextEntry() { + return this.getParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY); } /** - * @param {VideoStreamingProtocol} val - * @return {VideoStreamingFormat} - */ + * @param {TriggerSource} source - See TriggerSource Only is valid if resultCode is SUCCESS. + * @return {PerformInteractionResponse} + */ - setProtocol(val) { - this.validateType(VideoStreamingProtocol, val); - this.setParameter(VideoStreamingFormat.KEY_PROTOCOL, val); + setTriggerSource(source) { + this.validateType(TriggerSource, source); + this.setParameter(PerformInteractionResponse.KEY_TRIGGER_SOURCE, source); return this; } /** - * @return {VideoStreamingProtocol} - */ + * @return {TriggerSource} + */ - getProtocol() { - return this.getParameter(VideoStreamingFormat.KEY_PROTOCOL); + getTriggerSource() { + return this.getObject(TriggerSource, PerformInteractionResponse.KEY_TRIGGER_SOURCE); + } + + } + + PerformInteractionResponse.KEY_CHOICE_ID = 'choiceID'; + PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY = 'manualTextEntry'; + PerformInteractionResponse.KEY_TRIGGER_SOURCE = 'triggerSource'; + + /* eslint-disable camelcase */ + /** + * Deletes interaction choice set that has been created with "CreateInteractionChoiceSet". The interaction may only be + * deleted when not currently in use by a "performInteraction". + */ + + class DeleteInteractionChoiceSet extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteInteractionChoiceSet); } /** - * @param {VideoStreamingCodec} val - * @return {VideoStreamingFormat} - */ + * @param {Number} id - ID of the interaction choice set to delete. + * @return {DeleteInteractionChoiceSet} + */ - setCodec(val) { - this.validateType(VideoStreamingCodec, val); - this.setParameter(VideoStreamingFormat.KEY_CODEC, val); + setInteractionChoiceSetID(id) { + this.setParameter(DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID, id); return this; } /** - * @return {VideoStreamingCodec} - */ + * @return {Number} + */ - getCodec() { - return this.getParameter(VideoStreamingFormat.KEY_CODEC); + getInteractionChoiceSetID() { + return this.getParameter(DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID); + } + + } + + DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID = 'interactionChoiceSetID'; + + /* eslint-disable camelcase */ + + class DeleteInteractionChoiceSetResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteInteractionChoiceSet); + } + + } + + /* eslint-disable camelcase */ + /** + * Contains information about the SoftButton capabilities. + * @typedef {Enum} SoftButtonType + * @property {Object} _MAP + */ + + class SoftButtonType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get SBT_TEXT() { + return SoftButtonType._MAP.SBT_TEXT; + } + /** + * @return {String} + */ + + + static get SBT_IMAGE() { + return SoftButtonType._MAP.SBT_IMAGE; + } + /** + * @return {String} + */ + + + static get SBT_BOTH() { + return SoftButtonType._MAP.SBT_BOTH; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return SoftButtonType._valueForKey(key, SoftButtonType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return SoftButtonType._keyForValue(value, SoftButtonType._MAP); + } + + } + + SoftButtonType._MAP = Object.freeze({ + 'SBT_TEXT': 'TEXT', + 'SBT_IMAGE': 'IMAGE', + 'SBT_BOTH': 'BOTH' + }); + + /* eslint-disable camelcase */ + /** + * Enumeration that describes system actions that can be triggered. + * @typedef {Enum} SystemAction + * @property {Object} _MAP + */ + + class SystemAction extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Default action occurs. Standard behavior (e.g. SoftButton clears overlay). + * @return {String} + */ + + + static get DEFAULT_ACTION() { + return SystemAction._MAP.DEFAULT_ACTION; + } + /** + * App is brought into HMI_FULL. + * @return {String} + */ + + + static get STEAL_FOCUS() { + return SystemAction._MAP.STEAL_FOCUS; + } + /** + * Current system context is maintained. An overlay is persisted even though a SoftButton has been pressed and the + * notification sent. + * @return {String} + */ + + + static get KEEP_CONTEXT() { + return SystemAction._MAP.KEEP_CONTEXT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return SystemAction._valueForKey(key, SystemAction._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return SystemAction._keyForValue(value, SystemAction._MAP); + } + + } + + SystemAction._MAP = Object.freeze({ + 'DEFAULT_ACTION': 'DEFAULT_ACTION', + 'STEAL_FOCUS': 'STEAL_FOCUS', + 'KEEP_CONTEXT': 'KEEP_CONTEXT' + }); + + /* eslint-disable camelcase */ + + class SoftButton extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {SoftButtonType} type - Describes, whether it is text, highlighted text, icon, or dynamic image. See + * softButtonType + * @return {SoftButton} + */ + + + setType(type) { + this.validateType(SoftButtonType, type); + this.setParameter(SoftButton.KEY_TYPE, type); + return this; + } + /** + * @return {SoftButtonType} + */ + + + getType() { + return this.getObject(SoftButtonType, SoftButton.KEY_TYPE); + } + /** + * @param {String} text - Optional text to display (if defined as TEXT or BOTH) + * @return {SoftButton} + */ + + + setText(text) { + this.setParameter(SoftButton.KEY_TEXT, text); + return this; + } + /** + * @return {String} + */ + + + getText() { + return this.getParameter(SoftButton.KEY_TEXT); + } + /** + * @param {Image} image - Optional image struct for SoftButton (if defined as IMAGE or BOTH) + * @return {SoftButton} + */ + + + setImage(image) { + this.validateType(Image, image); + this.setParameter(SoftButton.KEY_IMAGE, image); + return this; + } + /** + * @return {Image} + */ + + + getImage() { + return this.getObject(Image, SoftButton.KEY_IMAGE); + } + /** + * @param {Boolean} highlighted - True, if highlighted False, if not highlighted + * @return {SoftButton} + */ + + + setIsHighlighted(highlighted) { + this.setParameter(SoftButton.KEY_IS_HIGHLIGHTED, highlighted); + return this; + } + /** + * @return {Boolean} + */ + + + getIsHighlighted() { + return this.getParameter(SoftButton.KEY_IS_HIGHLIGHTED); + } + /** + * @param {Number} id - Value which is returned via OnButtonPress / OnButtonEvent + * @return {SoftButton} + */ + + + setSoftButtonID(id) { + this.setParameter(SoftButton.KEY_SOFT_BUTTON_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getSoftButtonID() { + return this.getParameter(SoftButton.KEY_SOFT_BUTTON_ID); + } + /** + * @param {SystemAction} action - Parameter indicating whether selecting a SoftButton shall call a specific system + * action. This is intended to allow Notifications to bring the callee into full / + * focus; or in the case of persistent overlays, the overlay can persist when a + * SoftButton is pressed. + * @return {SoftButton} + */ + + + setSystemAction(action) { + this.validateType(SystemAction, action); + this.setParameter(SoftButton.KEY_SYSTEM_ACTION, action); + return this; + } + /** + * @return {SystemAction} + */ + + + getSystemAction() { + return this.getObject(SystemAction, SoftButton.KEY_SYSTEM_ACTION); + } + + } + + SoftButton.KEY_TYPE = 'type'; + SoftButton.KEY_TEXT = 'text'; + SoftButton.KEY_IMAGE = 'image'; + SoftButton.KEY_IS_HIGHLIGHTED = 'isHighlighted'; + SoftButton.KEY_SOFT_BUTTON_ID = 'softButtonID'; + SoftButton.KEY_SYSTEM_ACTION = 'systemAction'; + + /* eslint-disable camelcase */ + /** + * Shows an alert which typically consists of text-to-speech message and text on the display. At least either + * alertText1, alertText2 or TTSChunks need to be provided. + */ + + class Alert extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Alert); + } + /** + * @param {String} text1 - The first line of the alert text field + * @return {Alert} + */ + + + setAlertText1(text1) { + this.setParameter(Alert.KEY_ALERT_TEXT_1, text1); + return this; + } + /** + * @return {String} + */ + + + getAlertText1() { + return this.getParameter(Alert.KEY_ALERT_TEXT_1); + } + /** + * @param {String} text2 - The second line of the alert text field + * @return {Alert} + */ + + + setAlertText2(text2) { + this.setParameter(Alert.KEY_ALERT_TEXT_2, text2); + return this; + } + /** + * @return {String} + */ + + + getAlertText2() { + return this.getParameter(Alert.KEY_ALERT_TEXT_2); + } + /** + * @param {String} text3 - The optional third line of the alert text field + * @return {Alert} + */ + + + setAlertText3(text3) { + this.setParameter(Alert.KEY_ALERT_TEXT_3, text3); + return this; + } + /** + * @return {String} + */ + + + getAlertText3() { + return this.getParameter(Alert.KEY_ALERT_TEXT_3); + } + /** + * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. + * @return {Alert} + */ + + + setTtsChunks(chunks) { + this.validateType(TTSChunk, chunks, true); + this.setParameter(Alert.KEY_TTS_CHUNKS, chunks); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getTtsChunks() { + return this.getObject(TTSChunk, Alert.KEY_TTS_CHUNKS); + } + /** + * @param {Number} duration - Timeout in milliseconds. Typical timeouts are 3-5 seconds. If omitted, timeout is set + * to 5s. + * @return {Alert} + */ + + + setDuration(duration) { + this.setParameter(Alert.KEY_DURATION, duration); + return this; + } + /** + * @return {Number} + */ + + + getDuration() { + return this.getParameter(Alert.KEY_DURATION); + } + /** + * @param {Boolean} tone - Defines if tone should be played. Tone is played before TTS. If omitted, no tone is + * played. + * @return {Alert} + */ + + + setPlayTone(tone) { + this.setParameter(Alert.KEY_PLAY_TONE, tone); + return this; + } + /** + * @return {Boolean} + */ + + + getPlayTone() { + return this.getParameter(Alert.KEY_PLAY_TONE); + } + /** + * @param {Boolean} indicator - If supported on the given platform, the alert GUI will include some sort of + * animation indicating that loading of a feature is progressing. e.g. a spinning wheel + * or hourglass, etc. + * @return {Alert} + */ + + + setProgressIndicator(indicator) { + this.setParameter(Alert.KEY_PROGRESS_INDICATOR, indicator); + return this; + } + /** + * @return {Boolean} + */ + + + getProgressIndicator() { + return this.getParameter(Alert.KEY_PROGRESS_INDICATOR); + } + /** + * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, the displayed alert + * shall not have any SoftButtons. + * @return {Alert} + */ + + + setSoftButtons(buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(Alert.KEY_SOFT_BUTTONS, buttons); + return this; + } + /** + * @return {SoftButton[]} + */ + + + getSoftButtons() { + return this.getObject(SoftButton, Alert.KEY_SOFT_BUTTONS); + } + /** + * @param {Image} icon - Image struct determining whether static or dynamic icon. If omitted on supported displays, + * no (or the default if applicable) icon should be displayed. + * @return {Alert} + */ + + + setAlertIcon(icon) { + this.validateType(Image, icon); + this.setParameter(Alert.KEY_ALERT_ICON, icon); + return this; + } + /** + * @return {Image} + */ + + + getAlertIcon() { + return this.getObject(Image, Alert.KEY_ALERT_ICON); + } + /** + * @param {Number} id - An ID for this specific alert to allow cancellation through the `CancelInteraction` RPC. + * @return {Alert} + */ + + + setCancelID(id) { + this.setParameter(Alert.KEY_CANCEL_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCancelID() { + return this.getParameter(Alert.KEY_CANCEL_ID); + } + + } + + Alert.KEY_ALERT_TEXT_1 = 'alertText1'; + Alert.KEY_ALERT_TEXT_2 = 'alertText2'; + Alert.KEY_ALERT_TEXT_3 = 'alertText3'; + Alert.KEY_TTS_CHUNKS = 'ttsChunks'; + Alert.KEY_DURATION = 'duration'; + Alert.KEY_PLAY_TONE = 'playTone'; + Alert.KEY_PROGRESS_INDICATOR = 'progressIndicator'; + Alert.KEY_SOFT_BUTTONS = 'softButtons'; + Alert.KEY_ALERT_ICON = 'alertIcon'; + Alert.KEY_CANCEL_ID = 'cancelID'; + + /* eslint-disable camelcase */ + + class AlertResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Alert); + } + /** + * @param {Number} time - Amount of time (in seconds) that an app must wait before resending an alert. If provided, + * another system event or overlay currently has a higher priority than this alert. An app + * must not send an alert without waiting at least the amount of time dictated. + * @return {AlertResponse} + */ + + + setTryAgainTime(time) { + this.setParameter(AlertResponse.KEY_TRY_AGAIN_TIME, time); + return this; + } + /** + * @return {Number} + */ + + + getTryAgainTime() { + return this.getParameter(AlertResponse.KEY_TRY_AGAIN_TIME); + } + + } + + AlertResponse.KEY_TRY_AGAIN_TIME = 'tryAgainTime'; + + /* eslint-disable camelcase */ + /** + * The list of possible alignments, left, right, or centered + * @typedef {Enum} TextAlignment + * @property {Object} _MAP + */ + + class TextAlignment extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get LEFT_ALIGNED() { + return TextAlignment._MAP.LEFT_ALIGNED; + } + /** + * @return {String} + */ + + + static get RIGHT_ALIGNED() { + return TextAlignment._MAP.RIGHT_ALIGNED; + } + /** + * @return {String} + */ + + + static get CENTERED() { + return TextAlignment._MAP.CENTERED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return TextAlignment._valueForKey(key, TextAlignment._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return TextAlignment._keyForValue(value, TextAlignment._MAP); + } + + } + + TextAlignment._MAP = Object.freeze({ + 'LEFT_ALIGNED': 'LEFT_ALIGNED', + 'RIGHT_ALIGNED': 'RIGHT_ALIGNED', + 'CENTERED': 'CENTERED' + }); + + /* eslint-disable camelcase */ + + class TemplateConfiguration extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} template - Predefined or dynamically created window template. Currently only predefined window + * template layouts are defined. + * @return {TemplateConfiguration} + */ + + + setTemplate(template) { + this.setParameter(TemplateConfiguration.KEY_TEMPLATE, template); + return this; + } + /** + * @return {String} + */ + + + getTemplate() { + return this.getParameter(TemplateConfiguration.KEY_TEMPLATE); + } + /** + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {TemplateConfiguration} + */ + + + setDayColorScheme(scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(TemplateConfiguration.KEY_DAY_COLOR_SCHEME, scheme); + return this; + } + /** + * @return {TemplateColorScheme} + */ + + + getDayColorScheme() { + return this.getObject(TemplateColorScheme, TemplateConfiguration.KEY_DAY_COLOR_SCHEME); + } + /** + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {TemplateConfiguration} + */ + + + setNightColorScheme(scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME, scheme); + return this; + } + /** + * @return {TemplateColorScheme} + */ + + + getNightColorScheme() { + return this.getObject(TemplateColorScheme, TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME); + } + + } + + TemplateConfiguration.KEY_TEMPLATE = 'template'; + TemplateConfiguration.KEY_DAY_COLOR_SCHEME = 'dayColorScheme'; + TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} MetadataType + * @property {Object} _MAP + */ + + class MetadataType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * The data in this field contains the title of the currently playing audio track. + * @return {String} + */ + + + static get mediaTitle() { + return MetadataType._MAP.mediaTitle; + } + /** + * The data in this field contains the artist or creator of the currently playing audio track. + * @return {String} + */ + + + static get mediaArtist() { + return MetadataType._MAP.mediaArtist; + } + /** + * The data in this field contains the album title of the currently playing audio track. + * @return {String} + */ + + + static get mediaAlbum() { + return MetadataType._MAP.mediaAlbum; + } + /** + * The data in this field contains the creation year of the currently playing audio track. + * @return {String} + */ + + + static get mediaYear() { + return MetadataType._MAP.mediaYear; + } + /** + * The data in this field contains the genre of the currently playing audio track. + * @return {String} + */ + + + static get mediaGenre() { + return MetadataType._MAP.mediaGenre; + } + /** + * The data in this field contains the name of the current source for the media. + * @return {String} + */ + + + static get mediaStation() { + return MetadataType._MAP.mediaStation; + } + /** + * The data in this field is a rating. + * @return {String} + */ + + + static get rating() { + return MetadataType._MAP.rating; + } + /** + * The data in this field is the current temperature. + * @return {String} + */ + + + static get currentTemperature() { + return MetadataType._MAP.currentTemperature; + } + /** + * The data in this field is the maximum temperature for the day. + * @return {String} + */ + + + static get maximumTemperature() { + return MetadataType._MAP.maximumTemperature; + } + /** + * The data in this field is the minimum temperature for the day. + * @return {String} + */ + + + static get minimumTemperature() { + return MetadataType._MAP.minimumTemperature; + } + /** + * The data in this field describes the current weather (ex. cloudy, clear, etc.). + * @return {String} + */ + + + static get weatherTerm() { + return MetadataType._MAP.weatherTerm; + } + /** + * The data in this field describes the current humidity value. + * @return {String} + */ + + + static get humidity() { + return MetadataType._MAP.humidity; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return MetadataType._valueForKey(key, MetadataType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return MetadataType._keyForValue(value, MetadataType._MAP); + } + + } + + MetadataType._MAP = Object.freeze({ + 'mediaTitle': 'mediaTitle', + 'mediaArtist': 'mediaArtist', + 'mediaAlbum': 'mediaAlbum', + 'mediaYear': 'mediaYear', + 'mediaGenre': 'mediaGenre', + 'mediaStation': 'mediaStation', + 'rating': 'rating', + 'currentTemperature': 'currentTemperature', + 'maximumTemperature': 'maximumTemperature', + 'minimumTemperature': 'minimumTemperature', + 'weatherTerm': 'weatherTerm', + 'humidity': 'humidity' + }); + + /* eslint-disable camelcase */ + + class MetadataTags extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {MetadataType[]} field1 - The type of data contained in the "mainField1" text field. + * @return {MetadataTags} + */ + + + setMainField1(field1) { + this.validateType(MetadataType, field1, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_1, field1); + return this; + } + /** + * @return {MetadataType[]} + */ + + + getMainField1() { + return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_1); + } + /** + * @param {MetadataType[]} field2 - The type of data contained in the "mainField2" text field. + * @return {MetadataTags} + */ + + + setMainField2(field2) { + this.validateType(MetadataType, field2, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_2, field2); + return this; + } + /** + * @return {MetadataType[]} + */ + + + getMainField2() { + return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_2); + } + /** + * @param {MetadataType[]} field3 - The type of data contained in the "mainField3" text field. + * @return {MetadataTags} + */ + + + setMainField3(field3) { + this.validateType(MetadataType, field3, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_3, field3); + return this; + } + /** + * @return {MetadataType[]} + */ + + + getMainField3() { + return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_3); + } + /** + * @param {MetadataType[]} field4 - The type of data contained in the "mainField4" text field. + * @return {MetadataTags} + */ + + + setMainField4(field4) { + this.validateType(MetadataType, field4, true); + this.setParameter(MetadataTags.KEY_MAIN_FIELD_4, field4); + return this; + } + /** + * @return {MetadataType[]} + */ + + + getMainField4() { + return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_4); + } + + } + + MetadataTags.KEY_MAIN_FIELD_1 = 'mainField1'; + MetadataTags.KEY_MAIN_FIELD_2 = 'mainField2'; + MetadataTags.KEY_MAIN_FIELD_3 = 'mainField3'; + MetadataTags.KEY_MAIN_FIELD_4 = 'mainField4'; + + /* eslint-disable camelcase */ + /** + * Updates the persistent display. Supported fields depend on display capabilities. + */ + + class Show extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Show); + } + /** + * @param {String} field1 - The text that should be displayed in a single or upper display line. If this text is not + * set, the text of mainField1 stays unchanged. If this text is empty "", the field will be + * cleared. + * @return {Show} + */ + + + setMainField1(field1) { + this.setParameter(Show.KEY_MAIN_FIELD_1, field1); + return this; + } + /** + * @return {String} + */ + + + getMainField1() { + return this.getParameter(Show.KEY_MAIN_FIELD_1); + } + /** + * @param {String} field2 - The text that should be displayed on the second display line. If this text is not set, + * the text of mainField2 stays unchanged. If this text is empty "", the field will be + * cleared. + * @return {Show} + */ + + + setMainField2(field2) { + this.setParameter(Show.KEY_MAIN_FIELD_2, field2); + return this; + } + /** + * @return {String} + */ + + + getMainField2() { + return this.getParameter(Show.KEY_MAIN_FIELD_2); + } + /** + * @param {String} field3 - The text that should be displayed on the second "page" first display line. If this text + * is not set, the text of mainField3 stays unchanged. If this text is empty "", the field + * will be cleared. + * @return {Show} + */ + + + setMainField3(field3) { + this.setParameter(Show.KEY_MAIN_FIELD_3, field3); + return this; + } + /** + * @return {String} + */ + + + getMainField3() { + return this.getParameter(Show.KEY_MAIN_FIELD_3); + } + /** + * @param {String} field4 - The text that should be displayed on the second "page" second display line. If this text + * is not set, the text of mainField4 stays unchanged. If this text is empty "", the field + * will be cleared. + * @return {Show} + */ + + + setMainField4(field4) { + this.setParameter(Show.KEY_MAIN_FIELD_4, field4); + return this; + } + /** + * @return {String} + */ + + + getMainField4() { + return this.getParameter(Show.KEY_MAIN_FIELD_4); + } + /** + * @param {TextAlignment} alignment - Specifies how mainField1 and mainField2 texts should be aligned on display. If + * omitted, texts will be centered. + * @return {Show} + */ + + + setAlignment(alignment) { + this.validateType(TextAlignment, alignment); + this.setParameter(Show.KEY_ALIGNMENT, alignment); + return this; + } + /** + * @return {TextAlignment} + */ + + + getAlignment() { + return this.getObject(TextAlignment, Show.KEY_ALIGNMENT); + } + /** + * @param {String} bar - Requires investigation regarding the nav display capabilities. Potentially lower + * lowerStatusBar, upperStatusBar, titleBar, etc. + * @return {Show} + */ + + + setStatusBar(bar) { + this.setParameter(Show.KEY_STATUS_BAR, bar); + return this; + } + /** + * @return {String} + */ + + + getStatusBar() { + return this.getParameter(Show.KEY_STATUS_BAR); + } + /** + * @param {String} clock - Text value for MediaClock field. Has to be properly formatted by Mobile App according to + * the module's capabilities. If this text is set, any automatic media clock updates + * previously set with SetMediaClockTimer will be stopped. + * @return {Show} + */ + + + setMediaClock(clock) { + this.setParameter(Show.KEY_MEDIA_CLOCK, clock); + return this; + } + /** + * @return {String} + */ + + + getMediaClock() { + return this.getParameter(Show.KEY_MEDIA_CLOCK); + } + /** + * @param {String} track - The text that should be displayed in the track field. If this text is not set, the text + * of mediaTrack stays unchanged. If this text is empty "", the field will be cleared. + * @return {Show} + */ + + + setMediaTrack(track) { + this.setParameter(Show.KEY_MEDIA_TRACK, track); + return this; + } + /** + * @return {String} + */ + + + getMediaTrack() { + return this.getParameter(Show.KEY_MEDIA_TRACK); + } + /** + * @param {Image} graphic - Image struct determining whether static or dynamic image to display in app. If omitted + * on supported displays, the displayed graphic shall not change. + * @return {Show} + */ + + + setGraphic(graphic) { + this.validateType(Image, graphic); + this.setParameter(Show.KEY_GRAPHIC, graphic); + return this; + } + /** + * @return {Image} + */ + + + getGraphic() { + return this.getObject(Image, Show.KEY_GRAPHIC); + } + /** + * @param {Image} graphic - Image struct determining whether static or dynamic secondary image to display in app. If + * omitted on supported displays, the displayed secondary graphic shall not change. + * @return {Show} + */ + + + setSecondaryGraphic(graphic) { + this.validateType(Image, graphic); + this.setParameter(Show.KEY_SECONDARY_GRAPHIC, graphic); + return this; + } + /** + * @return {Image} + */ + + + getSecondaryGraphic() { + return this.getObject(Image, Show.KEY_SECONDARY_GRAPHIC); + } + /** + * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, the currently + * displayed SoftButton values will not change. + * @return {Show} + */ + + + setSoftButtons(buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(Show.KEY_SOFT_BUTTONS, buttons); + return this; + } + /** + * @return {SoftButton[]} + */ + + + getSoftButtons() { + return this.getObject(SoftButton, Show.KEY_SOFT_BUTTONS); + } + /** + * @param {String[]} presets - App labeled on-screen presets (i.e. on-screen media presets or dynamic search + * suggestions). If omitted on supported displays, the presets will be shown as not + * defined. + * @return {Show} + */ + + + setCustomPresets(presets) { + this.setParameter(Show.KEY_CUSTOM_PRESETS, presets); + return this; + } + /** + * @return {String[]} + */ + + + getCustomPresets() { + return this.getParameter(Show.KEY_CUSTOM_PRESETS); + } + /** + * @param {MetadataTags} tags - App defined metadata information. See MetadataStruct. Uses mainField1, mainField2, + * mainField3, mainField4. If omitted on supported displays, the currently set metadata + * tags will not change. If any text field contains no tags or the none tag, the + * metadata tag for that textfield should be removed. + * @return {Show} + */ + + + setMetadataTags(tags) { + this.validateType(MetadataTags, tags); + this.setParameter(Show.KEY_METADATA_TAGS, tags); + return this; + } + /** + * @return {MetadataTags} + */ + + + getMetadataTags() { + return this.getObject(MetadataTags, Show.KEY_METADATA_TAGS); + } + /** + * @param {String} title - The title of the new template that will be displayed. How this will be displayed is + * dependent on the OEM design and implementation of the template. + * @return {Show} + */ + + + setTemplateTitle(title) { + this.setParameter(Show.KEY_TEMPLATE_TITLE, title); + return this; + } + /** + * @return {String} + */ + + + getTemplateTitle() { + return this.getParameter(Show.KEY_TEMPLATE_TITLE); + } + /** + * @param {Number} id - This is the unique ID assigned to the window that this RPC is intended. If this param is not + * included, it will be assumed that this request is specifically for the main window on the + * main display. See PredefinedWindows enum. + * @return {Show} + */ + + + setWindowID(id) { + this.setParameter(Show.KEY_WINDOW_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getWindowID() { + return this.getParameter(Show.KEY_WINDOW_ID); + } + /** + * @param {TemplateConfiguration} configuration - Used to set an alternate template layout to a window. + * @return {Show} + */ + + + setTemplateConfiguration(configuration) { + this.validateType(TemplateConfiguration, configuration); + this.setParameter(Show.KEY_TEMPLATE_CONFIGURATION, configuration); + return this; + } + /** + * @return {TemplateConfiguration} + */ + + + getTemplateConfiguration() { + return this.getObject(TemplateConfiguration, Show.KEY_TEMPLATE_CONFIGURATION); + } + + } + + Show.KEY_MAIN_FIELD_1 = 'mainField1'; + Show.KEY_MAIN_FIELD_2 = 'mainField2'; + Show.KEY_MAIN_FIELD_3 = 'mainField3'; + Show.KEY_MAIN_FIELD_4 = 'mainField4'; + Show.KEY_ALIGNMENT = 'alignment'; + Show.KEY_STATUS_BAR = 'statusBar'; + Show.KEY_MEDIA_CLOCK = 'mediaClock'; + Show.KEY_MEDIA_TRACK = 'mediaTrack'; + Show.KEY_GRAPHIC = 'graphic'; + Show.KEY_SECONDARY_GRAPHIC = 'secondaryGraphic'; + Show.KEY_SOFT_BUTTONS = 'softButtons'; + Show.KEY_CUSTOM_PRESETS = 'customPresets'; + Show.KEY_METADATA_TAGS = 'metadataTags'; + Show.KEY_TEMPLATE_TITLE = 'templateTitle'; + Show.KEY_WINDOW_ID = 'windowID'; + Show.KEY_TEMPLATE_CONFIGURATION = 'templateConfiguration'; + + /* eslint-disable camelcase */ + + class ShowResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Show); + } + + } + + /* eslint-disable camelcase */ + /** + * Speaks a text. + */ + + class Speak extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Speak); + } + /** + * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. + * @return {Speak} + */ + + + setTtsChunks(chunks) { + this.validateType(TTSChunk, chunks, true); + this.setParameter(Speak.KEY_TTS_CHUNKS, chunks); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getTtsChunks() { + return this.getObject(TTSChunk, Speak.KEY_TTS_CHUNKS); + } + + } + + Speak.KEY_TTS_CHUNKS = 'ttsChunks'; + + /* eslint-disable camelcase */ + + class SpeakResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Speak); + } + + } + + /* eslint-disable camelcase */ + + class StartTime extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} hours - The hour of the media clock. Some radios only support a max of 19 hours. If out of range, + * it will be rejected. + * @return {StartTime} + */ + + + setHours(hours) { + this.setParameter(StartTime.KEY_HOURS, hours); + return this; + } + /** + * @return {Number} + */ + + + getHours() { + return this.getParameter(StartTime.KEY_HOURS); + } + /** + * @param {Number} minutes + * @return {StartTime} + */ + + + setMinutes(minutes) { + this.setParameter(StartTime.KEY_MINUTES, minutes); + return this; + } + /** + * @return {Number} + */ + + + getMinutes() { + return this.getParameter(StartTime.KEY_MINUTES); + } + /** + * @param {Number} seconds + * @return {StartTime} + */ + + + setSeconds(seconds) { + this.setParameter(StartTime.KEY_SECONDS, seconds); + return this; + } + /** + * @return {Number} + */ + + + getSeconds() { + return this.getParameter(StartTime.KEY_SECONDS); + } + + } + + StartTime.KEY_HOURS = 'hours'; + StartTime.KEY_MINUTES = 'minutes'; + StartTime.KEY_SECONDS = 'seconds'; + + /* eslint-disable camelcase */ + /** + * Describes how the media clock timer should behave on the platform + * @typedef {Enum} UpdateMode + * @property {Object} _MAP + */ + + class UpdateMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Starts the media clock timer counting upwards, as in time elapsed. + * @return {String} + */ + + + static get COUNTUP() { + return UpdateMode._MAP.COUNTUP; + } + /** + * Starts the media clock timer counting downwards, as in time remaining. + * @return {String} + */ + + + static get COUNTDOWN() { + return UpdateMode._MAP.COUNTDOWN; + } + /** + * Pauses the media clock timer + * @return {String} + */ + + + static get PAUSE() { + return UpdateMode._MAP.PAUSE; + } + /** + * Resume the media clock timer + * @return {String} + */ + + + static get RESUME() { + return UpdateMode._MAP.RESUME; + } + /** + * Clears the media clock timer (previously done through Show->mediaClock) + * @return {String} + */ + + + static get CLEAR() { + return UpdateMode._MAP.CLEAR; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return UpdateMode._valueForKey(key, UpdateMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return UpdateMode._keyForValue(value, UpdateMode._MAP); + } + + } + + UpdateMode._MAP = Object.freeze({ + 'COUNTUP': 'COUNTUP', + 'COUNTDOWN': 'COUNTDOWN', + 'PAUSE': 'PAUSE', + 'RESUME': 'RESUME', + 'CLEAR': 'CLEAR' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} AudioStreamingIndicator + * @property {Object} _MAP + */ + + class AudioStreamingIndicator extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Default playback indicator. By default the playback indicator should be PLAY_PAUSE when: - the media app is + * newly registered on the head unit (after RegisterAppInterface) - the media app was closed by the user (App + * enters HMI_NONE) - the app sends SetMediaClockTimer with audioStreamingIndicator not set to any value + * @return {String} + */ + + + static get PLAY_PAUSE() { + return AudioStreamingIndicator._MAP.PLAY_PAUSE; + } + /** + * Indicates that a button press of the Play/Pause button starts the audio playback. + * @return {String} + */ + + + static get PLAY() { + return AudioStreamingIndicator._MAP.PLAY; + } + /** + * Indicates that a button press of the Play/Pause button pauses the current audio playback. + * @return {String} + */ + + + static get PAUSE() { + return AudioStreamingIndicator._MAP.PAUSE; + } + /** + * Indicates that a button press of the Play/Pause button stops the current audio playback. + * @return {String} + */ + + + static get STOP() { + return AudioStreamingIndicator._MAP.STOP; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return AudioStreamingIndicator._valueForKey(key, AudioStreamingIndicator._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return AudioStreamingIndicator._keyForValue(value, AudioStreamingIndicator._MAP); + } + + } + + AudioStreamingIndicator._MAP = Object.freeze({ + 'PLAY_PAUSE': 'PLAY_PAUSE', + 'PLAY': 'PLAY', + 'PAUSE': 'PAUSE', + 'STOP': 'STOP' + }); + + /* eslint-disable camelcase */ + /** + * Sets the initial media clock value and automatic update method. + */ + + class SetMediaClockTimer extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetMediaClockTimer); + } + /** + * @param {StartTime} time - See StartTime. startTime must be provided for "COUNTUP" and "COUNTDOWN". startTime will + * be ignored for "RESUME", and "CLEAR" startTime can be sent for "PAUSE", in which case + * it will update the paused startTime + * @return {SetMediaClockTimer} + */ + + + setStartTime(time) { + this.validateType(StartTime, time); + this.setParameter(SetMediaClockTimer.KEY_START_TIME, time); + return this; + } + /** + * @return {StartTime} + */ + + + getStartTime() { + return this.getObject(StartTime, SetMediaClockTimer.KEY_START_TIME); + } + /** + * @param {StartTime} time - See StartTime. endTime can be provided for "COUNTUP" and "COUNTDOWN"; to be used to + * calculate any visual progress bar (if not provided, this feature is ignored) If endTime + * is greater then startTime for COUNTDOWN or less than startTime for COUNTUP, then the + * request will return an INVALID_DATA. endTime will be ignored for "RESUME", and "CLEAR" + * endTime can be sent for "PAUSE", in which case it will update the paused endTime + * @return {SetMediaClockTimer} + */ + + + setEndTime(time) { + this.validateType(StartTime, time); + this.setParameter(SetMediaClockTimer.KEY_END_TIME, time); + return this; + } + /** + * @return {StartTime} + */ + + + getEndTime() { + return this.getObject(StartTime, SetMediaClockTimer.KEY_END_TIME); + } + /** + * @param {UpdateMode} mode - Enumeration to control the media clock. In case of pause, resume, or clear, the start + * time value is ignored and shall be left out. For resume, the time continues with the + * same value as it was when paused. + * @return {SetMediaClockTimer} + */ + + + setUpdateMode(mode) { + this.validateType(UpdateMode, mode); + this.setParameter(SetMediaClockTimer.KEY_UPDATE_MODE, mode); + return this; + } + /** + * @return {UpdateMode} + */ + + + getUpdateMode() { + return this.getObject(UpdateMode, SetMediaClockTimer.KEY_UPDATE_MODE); + } + /** + * @param {AudioStreamingIndicator} indicator - Enumeration for the indicator icon on a play/pause button. see + * AudioStreamingIndicator. + * @return {SetMediaClockTimer} + */ + + + setAudioStreamingIndicator(indicator) { + this.validateType(AudioStreamingIndicator, indicator); + this.setParameter(SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR, indicator); + return this; + } + /** + * @return {AudioStreamingIndicator} + */ + + + getAudioStreamingIndicator() { + return this.getObject(AudioStreamingIndicator, SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR); + } + + } + + SetMediaClockTimer.KEY_START_TIME = 'startTime'; + SetMediaClockTimer.KEY_END_TIME = 'endTime'; + SetMediaClockTimer.KEY_UPDATE_MODE = 'updateMode'; + SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR = 'audioStreamingIndicator'; + + /* eslint-disable camelcase */ + + class SetMediaClockTimerResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetMediaClockTimer); + } + + } + + /* eslint-disable camelcase */ + /** + * Starts audio pass thru session + */ + + class PerformAudioPassThru extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PerformAudioPassThru); + } + /** + * @param {TTSChunk[]} prompt - The module will speak this prompt before opening the audio pass thru session. An + * array of text chunks of type TTSChunk. See TTSChunk. The array must have at least + * one item. If omitted, then no initial prompt is spoken. + * @return {PerformAudioPassThru} + */ + + + setInitialPrompt(prompt) { + this.validateType(TTSChunk, prompt, true); + this.setParameter(PerformAudioPassThru.KEY_INITIAL_PROMPT, prompt); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getInitialPrompt() { + return this.getObject(TTSChunk, PerformAudioPassThru.KEY_INITIAL_PROMPT); + } + /** + * @param {String} text1 - First line of text displayed during audio capture. + * @return {PerformAudioPassThru} + */ + + + setAudioPassThruDisplayText1(text1) { + this.setParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1, text1); + return this; + } + /** + * @return {String} + */ + + + getAudioPassThruDisplayText1() { + return this.getParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1); + } + /** + * @param {String} text2 - Second line of text displayed during audio capture. + * @return {PerformAudioPassThru} + */ + + + setAudioPassThruDisplayText2(text2) { + this.setParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2, text2); + return this; + } + /** + * @return {String} + */ + + + getAudioPassThruDisplayText2() { + return this.getParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2); + } + /** + * @param {SamplingRate} rate - This value shall be allowed at 8 kHz or 16 or 22 or 44 kHz. + * @return {PerformAudioPassThru} + */ + + + setSamplingRate(rate) { + this.validateType(SamplingRate, rate); + this.setParameter(PerformAudioPassThru.KEY_SAMPLING_RATE, rate); + return this; + } + /** + * @return {SamplingRate} + */ + + + getSamplingRate() { + return this.getObject(SamplingRate, PerformAudioPassThru.KEY_SAMPLING_RATE); + } + /** + * @param {Number} duration - The maximum duration of audio recording in milliseconds. + * @return {PerformAudioPassThru} + */ + + + setMaxDuration(duration) { + this.setParameter(PerformAudioPassThru.KEY_MAX_DURATION, duration); + return this; + } + /** + * @return {Number} + */ + + + getMaxDuration() { + return this.getParameter(PerformAudioPassThru.KEY_MAX_DURATION); + } + /** + * @param {BitsPerSample} sample - Specifies the quality the audio is recorded. Currently 8 bit or 16 bit. + * @return {PerformAudioPassThru} + */ + + + setBitsPerSample(sample) { + this.validateType(BitsPerSample, sample); + this.setParameter(PerformAudioPassThru.KEY_BITS_PER_SAMPLE, sample); + return this; + } + /** + * @return {BitsPerSample} + */ + + + getBitsPerSample() { + return this.getObject(BitsPerSample, PerformAudioPassThru.KEY_BITS_PER_SAMPLE); + } + /** + * @param {AudioType} type - Specifies the type of audio data being requested. + * @return {PerformAudioPassThru} + */ + + + setAudioType(type) { + this.validateType(AudioType, type); + this.setParameter(PerformAudioPassThru.KEY_AUDIO_TYPE, type); + return this; + } + /** + * @return {AudioType} + */ + + + getAudioType() { + return this.getObject(AudioType, PerformAudioPassThru.KEY_AUDIO_TYPE); + } + /** + * @param {Boolean} audio - Defines if the current audio source should be muted during the APT session. If not, the + * audio source will play without interruption. If omitted, the value is set to true. + * @return {PerformAudioPassThru} + */ + + + setMuteAudio(audio) { + this.setParameter(PerformAudioPassThru.KEY_MUTE_AUDIO, audio); + return this; + } + /** + * @return {Boolean} + */ + + + getMuteAudio() { + return this.getParameter(PerformAudioPassThru.KEY_MUTE_AUDIO); + } + + } + + PerformAudioPassThru.KEY_INITIAL_PROMPT = 'initialPrompt'; + PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1 = 'audioPassThruDisplayText1'; + PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2 = 'audioPassThruDisplayText2'; + PerformAudioPassThru.KEY_SAMPLING_RATE = 'samplingRate'; + PerformAudioPassThru.KEY_MAX_DURATION = 'maxDuration'; + PerformAudioPassThru.KEY_BITS_PER_SAMPLE = 'bitsPerSample'; + PerformAudioPassThru.KEY_AUDIO_TYPE = 'audioType'; + PerformAudioPassThru.KEY_MUTE_AUDIO = 'muteAudio'; + + /* eslint-disable camelcase */ + + class PerformAudioPassThruResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PerformAudioPassThru); + } + + } + + /* eslint-disable camelcase */ + /** + * When this request is invoked, the audio capture stops. + */ + + class EndAudioPassThru extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.EndAudioPassThru); + } + + } + + /* eslint-disable camelcase */ + + class EndAudioPassThruResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.EndAudioPassThru); + } + + } + + /* eslint-disable camelcase */ + /** + * Subscribes to built-in HMI buttons. The application will be notified by the OnButtonEvent and OnButtonPress. To + * unsubscribe the notifications, use unsubscribeButton. + */ + + class SubscribeButton extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SubscribeButton); + } + /** + * @param {ButtonName} name - Name of the button to subscribe. + * @return {SubscribeButton} + */ + + + setButtonName(name) { + this.validateType(ButtonName, name); + this.setParameter(SubscribeButton.KEY_BUTTON_NAME, name); + return this; + } + /** + * @return {ButtonName} + */ + + + getButtonName() { + return this.getObject(ButtonName, SubscribeButton.KEY_BUTTON_NAME); + } + + } + + SubscribeButton.KEY_BUTTON_NAME = 'buttonName'; + + /* eslint-disable camelcase */ + + class SubscribeButtonResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SubscribeButton); + } + + } + + /* eslint-disable camelcase */ + /** + * Unsubscribes from built-in HMI buttons. + */ + + class UnsubscribeButton extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeButton); + } + /** + * @param {ButtonName} name - Name of the button to unsubscribe. + * @return {UnsubscribeButton} + */ + + + setButtonName(name) { + this.validateType(ButtonName, name); + this.setParameter(UnsubscribeButton.KEY_BUTTON_NAME, name); + return this; + } + /** + * @return {ButtonName} + */ + + + getButtonName() { + return this.getObject(ButtonName, UnsubscribeButton.KEY_BUTTON_NAME); + } + + } + + UnsubscribeButton.KEY_BUTTON_NAME = 'buttonName'; + + /* eslint-disable camelcase */ + + class UnsubscribeButtonResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeButton); + } + + } + + /* eslint-disable camelcase */ + /** + * Subscribes for specific published data items. The data will be only sent if it has changed. The application will be + * notified by the onVehicleData notification whenever new data is available. To unsubscribe the notifications, use + * unsubscribe with the same subscriptionType. + */ + + class SubscribeVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SubscribeVehicleData); + } + /** + * @param {Boolean} gps - See GPSData + * @return {SubscribeVehicleData} + */ + + + setGps(gps) { + this.setParameter(SubscribeVehicleData.KEY_GPS, gps); + return this; + } + /** + * @return {Boolean} + */ + + + getGps() { + return this.getParameter(SubscribeVehicleData.KEY_GPS); + } + /** + * @param {Boolean} speed - The vehicle speed in kilometers per hour + * @return {SubscribeVehicleData} + */ + + + setSpeed(speed) { + this.setParameter(SubscribeVehicleData.KEY_SPEED, speed); + return this; + } + /** + * @return {Boolean} + */ + + + getSpeed() { + return this.getParameter(SubscribeVehicleData.KEY_SPEED); + } + /** + * @param {Boolean} rpm - The number of revolutions per minute of the engine + * @return {SubscribeVehicleData} + */ + + + setRpm(rpm) { + this.setParameter(SubscribeVehicleData.KEY_RPM, rpm); + return this; + } + /** + * @return {Boolean} + */ + + + getRpm() { + return this.getParameter(SubscribeVehicleData.KEY_RPM); + } + /** + * @param {Boolean} level - The fuel level in the tank (percentage) + * @return {SubscribeVehicleData} + */ + + + setFuelLevel(level) { + this.setParameter(SubscribeVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelLevel() { + return this.getParameter(SubscribeVehicleData.KEY_FUEL_LEVEL); + } + /** + * @param {Boolean} level_state - The fuel level state + * @return {SubscribeVehicleData} + */ + + + setFuelLevel_State(level_state) { + this.setParameter(SubscribeVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelLevel_State() { + return this.getParameter(SubscribeVehicleData.KEY_FUEL_LEVEL_STATE); + } + /** + * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres + * @return {SubscribeVehicleData} + */ + + + setInstantFuelConsumption(consumption) { + this.setParameter(SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + /** + * @return {Boolean} + */ + + + getInstantFuelConsumption() { + return this.getParameter(SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + /** + * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {SubscribeVehicleData} + */ + + + setFuelRange(range) { + this.setParameter(SubscribeVehicleData.KEY_FUEL_RANGE, range); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelRange() { + return this.getParameter(SubscribeVehicleData.KEY_FUEL_RANGE); + } + /** + * @param {Boolean} temperature - The external temperature in degrees celsius + * @return {SubscribeVehicleData} + */ + + + setExternalTemperature(temperature) { + this.setParameter(SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + /** + * @return {Boolean} + */ + + + getExternalTemperature() { + return this.getParameter(SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + /** + * @param {Boolean} signal - See TurnSignal + * @return {SubscribeVehicleData} + */ + + + setTurnSignal(signal) { + this.setParameter(SubscribeVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + /** + * @return {Boolean} + */ + + + getTurnSignal() { + return this.getParameter(SubscribeVehicleData.KEY_TURN_SIGNAL); + } + /** + * @param {Boolean} prndl - See PRNDL + * @return {SubscribeVehicleData} + */ + + + setPrndl(prndl) { + this.setParameter(SubscribeVehicleData.KEY_PRNDL, prndl); + return this; + } + /** + * @return {Boolean} + */ + + + getPrndl() { + return this.getParameter(SubscribeVehicleData.KEY_PRNDL); + } + /** + * @param {Boolean} pressure - See TireStatus + * @return {SubscribeVehicleData} + */ + + + setTirePressure(pressure) { + this.setParameter(SubscribeVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + /** + * @return {Boolean} + */ + + + getTirePressure() { + return this.getParameter(SubscribeVehicleData.KEY_TIRE_PRESSURE); + } + /** + * @param {Boolean} odometer - Odometer in km + * @return {SubscribeVehicleData} + */ + + + setOdometer(odometer) { + this.setParameter(SubscribeVehicleData.KEY_ODOMETER, odometer); + return this; + } + /** + * @return {Boolean} + */ + + + getOdometer() { + return this.getParameter(SubscribeVehicleData.KEY_ODOMETER); + } + /** + * @param {Boolean} status - The status of the seat belts + * @return {SubscribeVehicleData} + */ + + + setBeltStatus(status) { + this.setParameter(SubscribeVehicleData.KEY_BELT_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getBeltStatus() { + return this.getParameter(SubscribeVehicleData.KEY_BELT_STATUS); + } + /** + * @param {Boolean} information - The body information including power modes + * @return {SubscribeVehicleData} + */ + + + setBodyInformation(information) { + this.setParameter(SubscribeVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + /** + * @return {Boolean} + */ + + + getBodyInformation() { + return this.getParameter(SubscribeVehicleData.KEY_BODY_INFORMATION); + } + /** + * @param {Boolean} status - The device status including signal and battery strength + * @return {SubscribeVehicleData} + */ + + + setDeviceStatus(status) { + this.setParameter(SubscribeVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getDeviceStatus() { + return this.getParameter(SubscribeVehicleData.KEY_DEVICE_STATUS); + } + /** + * @param {Boolean} braking - The status of the brake pedal + * @return {SubscribeVehicleData} + */ + + + setDriverBraking(braking) { + this.setParameter(SubscribeVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + /** + * @return {Boolean} + */ + + + getDriverBraking() { + return this.getParameter(SubscribeVehicleData.KEY_DRIVER_BRAKING); + } + /** + * @param {Boolean} status - The status of the wipers + * @return {SubscribeVehicleData} + */ + + + setWiperStatus(status) { + this.setParameter(SubscribeVehicleData.KEY_WIPER_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getWiperStatus() { + return this.getParameter(SubscribeVehicleData.KEY_WIPER_STATUS); + } + /** + * @param {Boolean} status - Status of the head lamps + * @return {SubscribeVehicleData} + */ + + + setHeadLampStatus(status) { + this.setParameter(SubscribeVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getHeadLampStatus() { + return this.getParameter(SubscribeVehicleData.KEY_HEAD_LAMP_STATUS); + } + /** + * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {SubscribeVehicleData} + */ + + + setEngineTorque(torque) { + this.setParameter(SubscribeVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + /** + * @return {Boolean} + */ + + + getEngineTorque() { + return this.getParameter(SubscribeVehicleData.KEY_ENGINE_TORQUE); + } + /** + * @param {Boolean} position - Accelerator pedal position (percentage depressed) + * @return {SubscribeVehicleData} + */ + + + setAccPedalPosition(position) { + this.setParameter(SubscribeVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + /** + * @return {Boolean} + */ + + + getAccPedalPosition() { + return this.getParameter(SubscribeVehicleData.KEY_ACC_PEDAL_POSITION); + } + /** + * @param {Boolean} angle - Current angle of the steering wheel (in deg) + * @return {SubscribeVehicleData} + */ + + + setSteeringWheelAngle(angle) { + this.setParameter(SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + /** + * @return {Boolean} + */ + + + getSteeringWheelAngle() { + return this.getParameter(SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + /** + * @param {Boolean} life - The estimated percentage of remaining oil life of the engine. + * @return {SubscribeVehicleData} + */ + + + setEngineOilLife(life) { + this.setParameter(SubscribeVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + /** + * @return {Boolean} + */ + + + getEngineOilLife() { + return this.getParameter(SubscribeVehicleData.KEY_ENGINE_OIL_LIFE); + } + /** + * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {SubscribeVehicleData} + */ + + + setElectronicParkBrakeStatus(status) { + this.setParameter(SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getElectronicParkBrakeStatus() { + return this.getParameter(SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + /** + * @param {Boolean} id - Parameter used by cloud apps to identify a head unit + * @return {SubscribeVehicleData} + */ + + + setCloudAppVehicleID(id) { + this.setParameter(SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + /** + * @return {Boolean} + */ + + + getCloudAppVehicleID() { + return this.getParameter(SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + /** + * @param {Boolean} info - Emergency Call notification and confirmation data + * @return {SubscribeVehicleData} + */ + + + setECallInfo(info) { + this.setParameter(SubscribeVehicleData.KEY_E_CALL_INFO, info); + return this; + } + /** + * @return {Boolean} + */ + + + getECallInfo() { + return this.getParameter(SubscribeVehicleData.KEY_E_CALL_INFO); + } + /** + * @param {Boolean} status - The status of the air bags + * @return {SubscribeVehicleData} + */ + + + setAirbagStatus(status) { + this.setParameter(SubscribeVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getAirbagStatus() { + return this.getParameter(SubscribeVehicleData.KEY_AIRBAG_STATUS); + } + /** + * @param {Boolean} event - Information related to an emergency event (and if it occurred) + * @return {SubscribeVehicleData} + */ + + + setEmergencyEvent(event) { + this.setParameter(SubscribeVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + /** + * @return {Boolean} + */ + + + getEmergencyEvent() { + return this.getParameter(SubscribeVehicleData.KEY_EMERGENCY_EVENT); + } + /** + * @param {Boolean} status - The status modes of the cluster + * @return {SubscribeVehicleData} + */ + + + setClusterModeStatus(status) { + this.setParameter(SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getClusterModeStatus() { + return this.getParameter(SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS); + } + /** + * @param {Boolean} key - Information related to the MyKey feature + * @return {SubscribeVehicleData} + */ + + + setMyKey(key) { + this.setParameter(SubscribeVehicleData.KEY_MY_KEY, key); + return this; + } + /** + * @return {Boolean} + */ + + + getMyKey() { + return this.getParameter(SubscribeVehicleData.KEY_MY_KEY); + } + + } + + SubscribeVehicleData.KEY_GPS = 'gps'; + SubscribeVehicleData.KEY_SPEED = 'speed'; + SubscribeVehicleData.KEY_RPM = 'rpm'; + SubscribeVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; + SubscribeVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; + SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; + SubscribeVehicleData.KEY_FUEL_RANGE = 'fuelRange'; + SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; + SubscribeVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; + SubscribeVehicleData.KEY_PRNDL = 'prndl'; + SubscribeVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; + SubscribeVehicleData.KEY_ODOMETER = 'odometer'; + SubscribeVehicleData.KEY_BELT_STATUS = 'beltStatus'; + SubscribeVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; + SubscribeVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; + SubscribeVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; + SubscribeVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; + SubscribeVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; + SubscribeVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; + SubscribeVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; + SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; + SubscribeVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; + SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; + SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; + SubscribeVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; + SubscribeVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; + SubscribeVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; + SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; + SubscribeVehicleData.KEY_MY_KEY = 'myKey'; + + /* eslint-disable camelcase */ + /** + * Enumeration that describes possible result codes of a vehicle data entry request. + * @typedef {Enum} VehicleDataResultCode + * @property {Object} _MAP + */ + + class VehicleDataResultCode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Individual vehicle data item / DTC / DID request or subscription successful + * @return {String} + */ + + + static get VDRC_SUCCESS() { + return VehicleDataResultCode._MAP.VDRC_SUCCESS; + } + /** + * DTC / DID request successful, however, not all active DTCs or full contents of DID location available + * @return {String} + */ + + + static get VDRC_TRUNCATED_DATA() { + return VehicleDataResultCode._MAP.VDRC_TRUNCATED_DATA; + } + /** + * This vehicle data item is not allowed for this app by the OEM/Manufactorer of the connected module. + * @return {String} + */ + + + static get VDRC_DISALLOWED() { + return VehicleDataResultCode._MAP.VDRC_DISALLOWED; + } + /** + * The user has not granted access to this type of vehicle data item at this time. + * @return {String} + */ + + + static get VDRC_USER_DISALLOWED() { + return VehicleDataResultCode._MAP.VDRC_USER_DISALLOWED; + } + /** + * The ECU ID referenced is not a valid ID on the bus / system. + * @return {String} + */ + + + static get VDRC_INVALID_ID() { + return VehicleDataResultCode._MAP.VDRC_INVALID_ID; + } + /** + * The requested vehicle data item / DTC / DID is not currently available or responding on the bus / system. + * @return {String} + */ + + + static get VDRC_DATA_NOT_AVAILABLE() { + return VehicleDataResultCode._MAP.VDRC_DATA_NOT_AVAILABLE; + } + /** + * The vehicle data item is already subscribed. + * @return {String} + */ + + + static get VDRC_DATA_ALREADY_SUBSCRIBED() { + return VehicleDataResultCode._MAP.VDRC_DATA_ALREADY_SUBSCRIBED; + } + /** + * The vehicle data item cannot be unsubscribed because it is not currently subscribed. + * @return {String} + */ + + + static get VDRC_DATA_NOT_SUBSCRIBED() { + return VehicleDataResultCode._MAP.VDRC_DATA_NOT_SUBSCRIBED; + } + /** + * The request for this item is ignored because it is already in progress. + * @return {String} + */ + + + static get VDRC_IGNORED() { + return VehicleDataResultCode._MAP.VDRC_IGNORED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VehicleDataResultCode._valueForKey(key, VehicleDataResultCode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VehicleDataResultCode._keyForValue(value, VehicleDataResultCode._MAP); + } + + } + + VehicleDataResultCode._MAP = Object.freeze({ + 'VDRC_SUCCESS': 'SUCCESS', + 'VDRC_TRUNCATED_DATA': 'TRUNCATED_DATA', + 'VDRC_DISALLOWED': 'DISALLOWED', + 'VDRC_USER_DISALLOWED': 'USER_DISALLOWED', + 'VDRC_INVALID_ID': 'INVALID_ID', + 'VDRC_DATA_NOT_AVAILABLE': 'VEHICLE_DATA_NOT_AVAILABLE', + 'VDRC_DATA_ALREADY_SUBSCRIBED': 'DATA_ALREADY_SUBSCRIBED', + 'VDRC_DATA_NOT_SUBSCRIBED': 'DATA_NOT_SUBSCRIBED', + 'VDRC_IGNORED': 'IGNORED' + }); + + /* eslint-disable camelcase */ + /** + * Defines the data types that can be published and subscribed to. + * @typedef {Enum} VehicleDataType + * @property {Object} _MAP + */ + + class VehicleDataType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Notifies GPSData may be subscribed + * @return {String} + */ + + + static get VEHICLEDATA_GPS() { + return VehicleDataType._MAP.VEHICLEDATA_GPS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_SPEED() { + return VehicleDataType._MAP.VEHICLEDATA_SPEED; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_RPM() { + return VehicleDataType._MAP.VEHICLEDATA_RPM; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_FUELLEVEL() { + return VehicleDataType._MAP.VEHICLEDATA_FUELLEVEL; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_FUELLEVEL_STATE() { + return VehicleDataType._MAP.VEHICLEDATA_FUELLEVEL_STATE; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_FUELCONSUMPTION() { + return VehicleDataType._MAP.VEHICLEDATA_FUELCONSUMPTION; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_EXTERNTEMP() { + return VehicleDataType._MAP.VEHICLEDATA_EXTERNTEMP; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_VIN() { + return VehicleDataType._MAP.VEHICLEDATA_VIN; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_PRNDL() { + return VehicleDataType._MAP.VEHICLEDATA_PRNDL; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_TIREPRESSURE() { + return VehicleDataType._MAP.VEHICLEDATA_TIREPRESSURE; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_ODOMETER() { + return VehicleDataType._MAP.VEHICLEDATA_ODOMETER; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_BELTSTATUS() { + return VehicleDataType._MAP.VEHICLEDATA_BELTSTATUS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_BODYINFO() { + return VehicleDataType._MAP.VEHICLEDATA_BODYINFO; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_DEVICESTATUS() { + return VehicleDataType._MAP.VEHICLEDATA_DEVICESTATUS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_ECALLINFO() { + return VehicleDataType._MAP.VEHICLEDATA_ECALLINFO; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_AIRBAGSTATUS() { + return VehicleDataType._MAP.VEHICLEDATA_AIRBAGSTATUS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_EMERGENCYEVENT() { + return VehicleDataType._MAP.VEHICLEDATA_EMERGENCYEVENT; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_CLUSTERMODESTATUS() { + return VehicleDataType._MAP.VEHICLEDATA_CLUSTERMODESTATUS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_MYKEY() { + return VehicleDataType._MAP.VEHICLEDATA_MYKEY; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_BRAKING() { + return VehicleDataType._MAP.VEHICLEDATA_BRAKING; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_WIPERSTATUS() { + return VehicleDataType._MAP.VEHICLEDATA_WIPERSTATUS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_HEADLAMPSTATUS() { + return VehicleDataType._MAP.VEHICLEDATA_HEADLAMPSTATUS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_BATTVOLTAGE() { + return VehicleDataType._MAP.VEHICLEDATA_BATTVOLTAGE; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_ENGINETORQUE() { + return VehicleDataType._MAP.VEHICLEDATA_ENGINETORQUE; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_ACCPEDAL() { + return VehicleDataType._MAP.VEHICLEDATA_ACCPEDAL; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_STEERINGWHEEL() { + return VehicleDataType._MAP.VEHICLEDATA_STEERINGWHEEL; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_TURNSIGNAL() { + return VehicleDataType._MAP.VEHICLEDATA_TURNSIGNAL; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_FUELRANGE() { + return VehicleDataType._MAP.VEHICLEDATA_FUELRANGE; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_ENGINEOILLIFE() { + return VehicleDataType._MAP.VEHICLEDATA_ENGINEOILLIFE; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_ELECTRONICPARKBRAKESTATUS() { + return VehicleDataType._MAP.VEHICLEDATA_ELECTRONICPARKBRAKESTATUS; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_CLOUDAPPVEHICLEID() { + return VehicleDataType._MAP.VEHICLEDATA_CLOUDAPPVEHICLEID; + } + /** + * @return {String} + */ + + + static get VEHICLEDATA_OEM_CUSTOM_DATA() { + return VehicleDataType._MAP.VEHICLEDATA_OEM_CUSTOM_DATA; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VehicleDataType._valueForKey(key, VehicleDataType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VehicleDataType._keyForValue(value, VehicleDataType._MAP); + } + + } + + VehicleDataType._MAP = Object.freeze({ + 'VEHICLEDATA_GPS': 'VEHICLEDATA_GPS', + 'VEHICLEDATA_SPEED': 'VEHICLEDATA_SPEED', + 'VEHICLEDATA_RPM': 'VEHICLEDATA_RPM', + 'VEHICLEDATA_FUELLEVEL': 'VEHICLEDATA_FUELLEVEL', + 'VEHICLEDATA_FUELLEVEL_STATE': 'VEHICLEDATA_FUELLEVEL_STATE', + 'VEHICLEDATA_FUELCONSUMPTION': 'VEHICLEDATA_FUELCONSUMPTION', + 'VEHICLEDATA_EXTERNTEMP': 'VEHICLEDATA_EXTERNTEMP', + 'VEHICLEDATA_VIN': 'VEHICLEDATA_VIN', + 'VEHICLEDATA_PRNDL': 'VEHICLEDATA_PRNDL', + 'VEHICLEDATA_TIREPRESSURE': 'VEHICLEDATA_TIREPRESSURE', + 'VEHICLEDATA_ODOMETER': 'VEHICLEDATA_ODOMETER', + 'VEHICLEDATA_BELTSTATUS': 'VEHICLEDATA_BELTSTATUS', + 'VEHICLEDATA_BODYINFO': 'VEHICLEDATA_BODYINFO', + 'VEHICLEDATA_DEVICESTATUS': 'VEHICLEDATA_DEVICESTATUS', + 'VEHICLEDATA_ECALLINFO': 'VEHICLEDATA_ECALLINFO', + 'VEHICLEDATA_AIRBAGSTATUS': 'VEHICLEDATA_AIRBAGSTATUS', + 'VEHICLEDATA_EMERGENCYEVENT': 'VEHICLEDATA_EMERGENCYEVENT', + 'VEHICLEDATA_CLUSTERMODESTATUS': 'VEHICLEDATA_CLUSTERMODESTATUS', + 'VEHICLEDATA_MYKEY': 'VEHICLEDATA_MYKEY', + 'VEHICLEDATA_BRAKING': 'VEHICLEDATA_BRAKING', + 'VEHICLEDATA_WIPERSTATUS': 'VEHICLEDATA_WIPERSTATUS', + 'VEHICLEDATA_HEADLAMPSTATUS': 'VEHICLEDATA_HEADLAMPSTATUS', + 'VEHICLEDATA_BATTVOLTAGE': 'VEHICLEDATA_BATTVOLTAGE', + 'VEHICLEDATA_ENGINETORQUE': 'VEHICLEDATA_ENGINETORQUE', + 'VEHICLEDATA_ACCPEDAL': 'VEHICLEDATA_ACCPEDAL', + 'VEHICLEDATA_STEERINGWHEEL': 'VEHICLEDATA_STEERINGWHEEL', + 'VEHICLEDATA_TURNSIGNAL': 'VEHICLEDATA_TURNSIGNAL', + 'VEHICLEDATA_FUELRANGE': 'VEHICLEDATA_FUELRANGE', + 'VEHICLEDATA_ENGINEOILLIFE': 'VEHICLEDATA_ENGINEOILLIFE', + 'VEHICLEDATA_ELECTRONICPARKBRAKESTATUS': 'VEHICLEDATA_ELECTRONICPARKBRAKESTATUS', + 'VEHICLEDATA_CLOUDAPPVEHICLEID': 'VEHICLEDATA_CLOUDAPPVEHICLEID', + 'VEHICLEDATA_OEM_CUSTOM_DATA': 'VEHICLEDATA_OEM_CUSTOM_DATA' + }); + + /* eslint-disable camelcase */ + /** + * Individual published data request result + */ + + class VehicleDataResult extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {VehicleDataType} type - Defined published data element type. + * @return {VehicleDataResult} + */ + + + setDataType(type) { + this.validateType(VehicleDataType, type); + this.setParameter(VehicleDataResult.KEY_DATA_TYPE, type); + return this; + } + /** + * @return {VehicleDataType} + */ + + + getDataType() { + return this.getObject(VehicleDataType, VehicleDataResult.KEY_DATA_TYPE); + } + /** + * @param {VehicleDataResultCode} code - Published data result code. + * @return {VehicleDataResult} + */ + + + setResultCode(code) { + this.validateType(VehicleDataResultCode, code); + this.setParameter(VehicleDataResult.KEY_RESULT_CODE, code); + return this; + } + /** + * @return {VehicleDataResultCode} + */ + + + getResultCode() { + return this.getObject(VehicleDataResultCode, VehicleDataResult.KEY_RESULT_CODE); + } + /** + * @param {String} type - Type of requested oem specific parameter + * @return {VehicleDataResult} + */ + + + setOemCustomDataType(type) { + this.setParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getOemCustomDataType() { + return this.getParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE); + } + + } + + VehicleDataResult.KEY_DATA_TYPE = 'dataType'; + VehicleDataResult.KEY_RESULT_CODE = 'resultCode'; + VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE = 'oemCustomDataType'; + + /* eslint-disable camelcase */ + + class SubscribeVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SubscribeVehicleData); + } + /** + * @param {VehicleDataResult} gps - See GPSData + * @return {SubscribeVehicleDataResponse} + */ + + + setGps(gps) { + this.validateType(VehicleDataResult, gps); + this.setParameter(SubscribeVehicleDataResponse.KEY_GPS, gps); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getGps() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_GPS); + } + /** + * @param {VehicleDataResult} speed - The vehicle speed in kilometers per hour + * @return {SubscribeVehicleDataResponse} + */ + + + setSpeed(speed) { + this.validateType(VehicleDataResult, speed); + this.setParameter(SubscribeVehicleDataResponse.KEY_SPEED, speed); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getSpeed() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_SPEED); + } + /** + * @param {VehicleDataResult} rpm - The number of revolutions per minute of the engine + * @return {SubscribeVehicleDataResponse} + */ + + + setRpm(rpm) { + this.validateType(VehicleDataResult, rpm); + this.setParameter(SubscribeVehicleDataResponse.KEY_RPM, rpm); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getRpm() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_RPM); + } + /** + * @param {VehicleDataResult} level - The fuel level in the tank (percentage) + * @return {SubscribeVehicleDataResponse} + */ + + + setFuelLevel(level) { + this.validateType(VehicleDataResult, level); + this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_LEVEL, level); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getFuelLevel() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_LEVEL); + } + /** + * @param {VehicleDataResult} level_state - The fuel level state + * @return {SubscribeVehicleDataResponse} + */ + + + setFuelLevel_State(level_state) { + this.validateType(VehicleDataResult, level_state); + this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getFuelLevel_State() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE); + } + /** + * @param {VehicleDataResult} consumption - The instantaneous fuel consumption in microlitres + * @return {SubscribeVehicleDataResponse} + */ + + + setInstantFuelConsumption(consumption) { + this.validateType(VehicleDataResult, consumption); + this.setParameter(SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getInstantFuelConsumption() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION); + } + /** + * @param {VehicleDataResult} range - The estimate range in KM the vehicle can travel based on fuel level and + * consumption + * @return {SubscribeVehicleDataResponse} + */ + + + setFuelRange(range) { + this.validateType(VehicleDataResult, range); + this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_RANGE, range); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getFuelRange() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_RANGE); + } + /** + * @param {VehicleDataResult} temperature - The external temperature in degrees celsius. + * @return {SubscribeVehicleDataResponse} + */ + + + setExternalTemperature(temperature) { + this.validateType(VehicleDataResult, temperature); + this.setParameter(SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getExternalTemperature() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE); + } + /** + * @param {VehicleDataResult} signal - See TurnSignal + * @return {SubscribeVehicleDataResponse} + */ + + + setTurnSignal(signal) { + this.validateType(VehicleDataResult, signal); + this.setParameter(SubscribeVehicleDataResponse.KEY_TURN_SIGNAL, signal); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getTurnSignal() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_TURN_SIGNAL); + } + /** + * @param {VehicleDataResult} prndl - See PRNDL + * @return {SubscribeVehicleDataResponse} + */ + + + setPrndl(prndl) { + this.validateType(VehicleDataResult, prndl); + this.setParameter(SubscribeVehicleDataResponse.KEY_PRNDL, prndl); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getPrndl() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_PRNDL); + } + /** + * @param {VehicleDataResult} pressure - See TireStatus + * @return {SubscribeVehicleDataResponse} + */ + + + setTirePressure(pressure) { + this.validateType(VehicleDataResult, pressure); + this.setParameter(SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE, pressure); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getTirePressure() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE); + } + /** + * @param {VehicleDataResult} odometer - Odometer in km + * @return {SubscribeVehicleDataResponse} + */ + + + setOdometer(odometer) { + this.validateType(VehicleDataResult, odometer); + this.setParameter(SubscribeVehicleDataResponse.KEY_ODOMETER, odometer); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getOdometer() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ODOMETER); + } + /** + * @param {VehicleDataResult} status - The status of the seat belts + * @return {SubscribeVehicleDataResponse} + */ + + + setBeltStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_BELT_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getBeltStatus() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_BELT_STATUS); + } + /** + * @param {VehicleDataResult} information - The body information including power modes + * @return {SubscribeVehicleDataResponse} + */ + + + setBodyInformation(information) { + this.validateType(VehicleDataResult, information); + this.setParameter(SubscribeVehicleDataResponse.KEY_BODY_INFORMATION, information); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getBodyInformation() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_BODY_INFORMATION); + } + /** + * @param {VehicleDataResult} status - The device status including signal and battery strength + * @return {SubscribeVehicleDataResponse} + */ + + + setDeviceStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_DEVICE_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getDeviceStatus() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_DEVICE_STATUS); + } + /** + * @param {VehicleDataResult} braking - The status of the brake pedal + * @return {SubscribeVehicleDataResponse} + */ + + + setDriverBraking(braking) { + this.validateType(VehicleDataResult, braking); + this.setParameter(SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING, braking); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getDriverBraking() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING); + } + /** + * @param {VehicleDataResult} status - The status of the wipers + * @return {SubscribeVehicleDataResponse} + */ + + + setWiperStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_WIPER_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getWiperStatus() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_WIPER_STATUS); + } + /** + * @param {VehicleDataResult} status - Status of the head lamps + * @return {SubscribeVehicleDataResponse} + */ + + + setHeadLampStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getHeadLampStatus() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS); + } + /** + * @param {VehicleDataResult} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {SubscribeVehicleDataResponse} + */ + + + setEngineTorque(torque) { + this.validateType(VehicleDataResult, torque); + this.setParameter(SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE, torque); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getEngineTorque() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE); + } + /** + * @param {VehicleDataResult} position - Accelerator pedal position (percentage depressed) + * @return {SubscribeVehicleDataResponse} + */ + + + setAccPedalPosition(position) { + this.validateType(VehicleDataResult, position); + this.setParameter(SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getAccPedalPosition() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION); + } + /** + * @param {VehicleDataResult} angle - Current angle of the steering wheel (in deg) + * @return {SubscribeVehicleDataResponse} + */ + + + setSteeringWheelAngle(angle) { + this.validateType(VehicleDataResult, angle); + this.setParameter(SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getSteeringWheelAngle() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE); + } + /** + * @param {VehicleDataResult} life - The estimated percentage of remaining oil life of the engine. + * @return {SubscribeVehicleDataResponse} + */ + + + setEngineOilLife(life) { + this.validateType(VehicleDataResult, life); + this.setParameter(SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getEngineOilLife() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE); + } + /** + * @param {VehicleDataResult} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {SubscribeVehicleDataResponse} + */ + + + setElectronicParkBrakeStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getElectronicParkBrakeStatus() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + /** + * @param {VehicleDataResult} id - Parameter used by cloud apps to identify a head unit + * @return {SubscribeVehicleDataResponse} + */ + + + setCloudAppVehicleID(id) { + this.validateType(VehicleDataResult, id); + this.setParameter(SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getCloudAppVehicleID() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID); + } + /** + * @param {VehicleDataResult} info - Emergency Call notification and confirmation data + * @return {SubscribeVehicleDataResponse} + */ + + + setECallInfo(info) { + this.validateType(VehicleDataResult, info); + this.setParameter(SubscribeVehicleDataResponse.KEY_E_CALL_INFO, info); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getECallInfo() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_E_CALL_INFO); + } + /** + * @param {VehicleDataResult} status - The status of the air bags + * @return {SubscribeVehicleDataResponse} + */ + + + setAirbagStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getAirbagStatus() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS); + } + /** + * @param {VehicleDataResult} event - Information related to an emergency event (and if it occurred) + * @return {SubscribeVehicleDataResponse} + */ + + + setEmergencyEvent(event) { + this.validateType(VehicleDataResult, event); + this.setParameter(SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT, event); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getEmergencyEvent() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT); + } + /** + * @param {VehicleDataResult} modes - The status modes of the cluster + * @return {SubscribeVehicleDataResponse} + */ + + + setClusterModes(modes) { + this.validateType(VehicleDataResult, modes); + this.setParameter(SubscribeVehicleDataResponse.KEY_CLUSTER_MODES, modes); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getClusterModes() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_CLUSTER_MODES); + } + /** + * @param {VehicleDataResult} key - Information related to the MyKey feature + * @return {SubscribeVehicleDataResponse} + */ + + + setMyKey(key) { + this.validateType(VehicleDataResult, key); + this.setParameter(SubscribeVehicleDataResponse.KEY_MY_KEY, key); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getMyKey() { + return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_MY_KEY); + } + + } + + SubscribeVehicleDataResponse.KEY_GPS = 'gps'; + SubscribeVehicleDataResponse.KEY_SPEED = 'speed'; + SubscribeVehicleDataResponse.KEY_RPM = 'rpm'; + SubscribeVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel'; + SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; + SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; + SubscribeVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange'; + SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; + SubscribeVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal'; + SubscribeVehicleDataResponse.KEY_PRNDL = 'prndl'; + SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure'; + SubscribeVehicleDataResponse.KEY_ODOMETER = 'odometer'; + SubscribeVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus'; + SubscribeVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation'; + SubscribeVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus'; + SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking'; + SubscribeVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus'; + SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; + SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque'; + SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; + SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; + SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; + SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; + SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; + SubscribeVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo'; + SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus'; + SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent'; + SubscribeVehicleDataResponse.KEY_CLUSTER_MODES = 'clusterModes'; + SubscribeVehicleDataResponse.KEY_MY_KEY = 'myKey'; + + /* eslint-disable camelcase */ + /** + * This function is used to unsubscribe the notifications from the subscribeVehicleData function. + */ + + class UnsubscribeVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeVehicleData); + } + /** + * @param {Boolean} gps - See GPSData + * @return {UnsubscribeVehicleData} + */ + + + setGps(gps) { + this.setParameter(UnsubscribeVehicleData.KEY_GPS, gps); + return this; + } + /** + * @return {Boolean} + */ + + + getGps() { + return this.getParameter(UnsubscribeVehicleData.KEY_GPS); + } + /** + * @param {Boolean} speed - The vehicle speed in kilometers per hour + * @return {UnsubscribeVehicleData} + */ + + + setSpeed(speed) { + this.setParameter(UnsubscribeVehicleData.KEY_SPEED, speed); + return this; + } + /** + * @return {Boolean} + */ + + + getSpeed() { + return this.getParameter(UnsubscribeVehicleData.KEY_SPEED); + } + /** + * @param {Boolean} rpm - The number of revolutions per minute of the engine + * @return {UnsubscribeVehicleData} + */ + + + setRpm(rpm) { + this.setParameter(UnsubscribeVehicleData.KEY_RPM, rpm); + return this; + } + /** + * @return {Boolean} + */ + + + getRpm() { + return this.getParameter(UnsubscribeVehicleData.KEY_RPM); + } + /** + * @param {Boolean} level - The fuel level in the tank (percentage) + * @return {UnsubscribeVehicleData} + */ + + + setFuelLevel(level) { + this.setParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelLevel() { + return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL); + } + /** + * @param {Boolean} level_state - The fuel level state + * @return {UnsubscribeVehicleData} + */ + + + setFuelLevel_State(level_state) { + this.setParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelLevel_State() { + return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE); + } + /** + * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres + * @return {UnsubscribeVehicleData} + */ + + + setInstantFuelConsumption(consumption) { + this.setParameter(UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + /** + * @return {Boolean} + */ + + + getInstantFuelConsumption() { + return this.getParameter(UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + /** + * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {UnsubscribeVehicleData} + */ + + + setFuelRange(range) { + this.setParameter(UnsubscribeVehicleData.KEY_FUEL_RANGE, range); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelRange() { + return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_RANGE); + } + /** + * @param {Boolean} temperature - The external temperature in degrees celsius. + * @return {UnsubscribeVehicleData} + */ + + + setExternalTemperature(temperature) { + this.setParameter(UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + /** + * @return {Boolean} + */ + + + getExternalTemperature() { + return this.getParameter(UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + /** + * @param {Boolean} signal - See TurnSignal + * @return {UnsubscribeVehicleData} + */ + + + setTurnSignal(signal) { + this.setParameter(UnsubscribeVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + /** + * @return {Boolean} + */ + + + getTurnSignal() { + return this.getParameter(UnsubscribeVehicleData.KEY_TURN_SIGNAL); + } + /** + * @param {Boolean} prndl - See PRNDL + * @return {UnsubscribeVehicleData} + */ + + + setPrndl(prndl) { + this.setParameter(UnsubscribeVehicleData.KEY_PRNDL, prndl); + return this; + } + /** + * @return {Boolean} + */ + + + getPrndl() { + return this.getParameter(UnsubscribeVehicleData.KEY_PRNDL); + } + /** + * @param {Boolean} pressure - See TireStatus + * @return {UnsubscribeVehicleData} + */ + + + setTirePressure(pressure) { + this.setParameter(UnsubscribeVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + /** + * @return {Boolean} + */ + + + getTirePressure() { + return this.getParameter(UnsubscribeVehicleData.KEY_TIRE_PRESSURE); + } + /** + * @param {Boolean} odometer - Odometer in km + * @return {UnsubscribeVehicleData} + */ + + + setOdometer(odometer) { + this.setParameter(UnsubscribeVehicleData.KEY_ODOMETER, odometer); + return this; + } + /** + * @return {Boolean} + */ + + + getOdometer() { + return this.getParameter(UnsubscribeVehicleData.KEY_ODOMETER); + } + /** + * @param {Boolean} status - The status of the seat belts + * @return {UnsubscribeVehicleData} + */ + + + setBeltStatus(status) { + this.setParameter(UnsubscribeVehicleData.KEY_BELT_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getBeltStatus() { + return this.getParameter(UnsubscribeVehicleData.KEY_BELT_STATUS); + } + /** + * @param {Boolean} information - The body information including power modes + * @return {UnsubscribeVehicleData} + */ + + + setBodyInformation(information) { + this.setParameter(UnsubscribeVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + /** + * @return {Boolean} + */ + + + getBodyInformation() { + return this.getParameter(UnsubscribeVehicleData.KEY_BODY_INFORMATION); + } + /** + * @param {Boolean} status - The device status including signal and battery strength + * @return {UnsubscribeVehicleData} + */ + + + setDeviceStatus(status) { + this.setParameter(UnsubscribeVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getDeviceStatus() { + return this.getParameter(UnsubscribeVehicleData.KEY_DEVICE_STATUS); + } + /** + * @param {Boolean} braking - The status of the brake pedal + * @return {UnsubscribeVehicleData} + */ + + + setDriverBraking(braking) { + this.setParameter(UnsubscribeVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + /** + * @return {Boolean} + */ + + + getDriverBraking() { + return this.getParameter(UnsubscribeVehicleData.KEY_DRIVER_BRAKING); + } + /** + * @param {Boolean} status - The status of the wipers + * @return {UnsubscribeVehicleData} + */ + + + setWiperStatus(status) { + this.setParameter(UnsubscribeVehicleData.KEY_WIPER_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getWiperStatus() { + return this.getParameter(UnsubscribeVehicleData.KEY_WIPER_STATUS); + } + /** + * @param {Boolean} status - Status of the head lamps + * @return {UnsubscribeVehicleData} + */ + + + setHeadLampStatus(status) { + this.setParameter(UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getHeadLampStatus() { + return this.getParameter(UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS); + } + /** + * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {UnsubscribeVehicleData} + */ + + + setEngineTorque(torque) { + this.setParameter(UnsubscribeVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + /** + * @return {Boolean} + */ + + + getEngineTorque() { + return this.getParameter(UnsubscribeVehicleData.KEY_ENGINE_TORQUE); + } + /** + * @param {Boolean} position - Accelerator pedal position (percentage depressed) + * @return {UnsubscribeVehicleData} + */ + + + setAccPedalPosition(position) { + this.setParameter(UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + /** + * @return {Boolean} + */ + + + getAccPedalPosition() { + return this.getParameter(UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION); + } + /** + * @param {Boolean} angle - Current angle of the steering wheel (in deg) + * @return {UnsubscribeVehicleData} + */ + + + setSteeringWheelAngle(angle) { + this.setParameter(UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + /** + * @return {Boolean} + */ + + + getSteeringWheelAngle() { + return this.getParameter(UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + /** + * @param {Boolean} life - The estimated percentage of remaining oil life of the engine. + * @return {UnsubscribeVehicleData} + */ + + + setEngineOilLife(life) { + this.setParameter(UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + /** + * @return {Boolean} + */ + + + getEngineOilLife() { + return this.getParameter(UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE); + } + /** + * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {UnsubscribeVehicleData} + */ + + + setElectronicParkBrakeStatus(status) { + this.setParameter(UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getElectronicParkBrakeStatus() { + return this.getParameter(UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + /** + * @param {Boolean} id - Parameter used by cloud apps to identify a head unit + * @return {UnsubscribeVehicleData} + */ + + + setCloudAppVehicleID(id) { + this.setParameter(UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + /** + * @return {Boolean} + */ + + + getCloudAppVehicleID() { + return this.getParameter(UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + /** + * @param {Boolean} info - Emergency Call notification and confirmation data + * @return {UnsubscribeVehicleData} + */ + + + setECallInfo(info) { + this.setParameter(UnsubscribeVehicleData.KEY_E_CALL_INFO, info); + return this; + } + /** + * @return {Boolean} + */ + + + getECallInfo() { + return this.getParameter(UnsubscribeVehicleData.KEY_E_CALL_INFO); + } + /** + * @param {Boolean} status - The status of the air bags + * @return {UnsubscribeVehicleData} + */ + + + setAirbagStatus(status) { + this.setParameter(UnsubscribeVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getAirbagStatus() { + return this.getParameter(UnsubscribeVehicleData.KEY_AIRBAG_STATUS); + } + /** + * @param {Boolean} event - Information related to an emergency event (and if it occurred) + * @return {UnsubscribeVehicleData} + */ + + + setEmergencyEvent(event) { + this.setParameter(UnsubscribeVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + /** + * @return {Boolean} + */ + + + getEmergencyEvent() { + return this.getParameter(UnsubscribeVehicleData.KEY_EMERGENCY_EVENT); + } + /** + * @param {Boolean} status - The status modes of the cluster + * @return {UnsubscribeVehicleData} + */ + + + setClusterModeStatus(status) { + this.setParameter(UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getClusterModeStatus() { + return this.getParameter(UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS); + } + /** + * @param {Boolean} key - Information related to the MyKey feature + * @return {UnsubscribeVehicleData} + */ + + + setMyKey(key) { + this.setParameter(UnsubscribeVehicleData.KEY_MY_KEY, key); + return this; + } + /** + * @return {Boolean} + */ + + + getMyKey() { + return this.getParameter(UnsubscribeVehicleData.KEY_MY_KEY); + } + + } + + UnsubscribeVehicleData.KEY_GPS = 'gps'; + UnsubscribeVehicleData.KEY_SPEED = 'speed'; + UnsubscribeVehicleData.KEY_RPM = 'rpm'; + UnsubscribeVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; + UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; + UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; + UnsubscribeVehicleData.KEY_FUEL_RANGE = 'fuelRange'; + UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; + UnsubscribeVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; + UnsubscribeVehicleData.KEY_PRNDL = 'prndl'; + UnsubscribeVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; + UnsubscribeVehicleData.KEY_ODOMETER = 'odometer'; + UnsubscribeVehicleData.KEY_BELT_STATUS = 'beltStatus'; + UnsubscribeVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; + UnsubscribeVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; + UnsubscribeVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; + UnsubscribeVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; + UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; + UnsubscribeVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; + UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; + UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; + UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; + UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; + UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; + UnsubscribeVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; + UnsubscribeVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; + UnsubscribeVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; + UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; + UnsubscribeVehicleData.KEY_MY_KEY = 'myKey'; + + /* eslint-disable camelcase */ + + class UnsubscribeVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeVehicleData); + } + /** + * @param {VehicleDataResult} gps - See GPSData + * @return {UnsubscribeVehicleDataResponse} + */ + + + setGps(gps) { + this.validateType(VehicleDataResult, gps); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_GPS, gps); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getGps() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_GPS); + } + /** + * @param {VehicleDataResult} speed - The vehicle speed in kilometers per hour + * @return {UnsubscribeVehicleDataResponse} + */ + + + setSpeed(speed) { + this.validateType(VehicleDataResult, speed); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_SPEED, speed); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getSpeed() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_SPEED); + } + /** + * @param {VehicleDataResult} rpm - The number of revolutions per minute of the engine + * @return {UnsubscribeVehicleDataResponse} + */ + + + setRpm(rpm) { + this.validateType(VehicleDataResult, rpm); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_RPM, rpm); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getRpm() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_RPM); + } + /** + * @param {VehicleDataResult} level - The fuel level in the tank (percentage) + * @return {UnsubscribeVehicleDataResponse} + */ + + + setFuelLevel(level) { + this.validateType(VehicleDataResult, level); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL, level); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getFuelLevel() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL); + } + /** + * @param {VehicleDataResult} level_state - The fuel level state + * @return {UnsubscribeVehicleDataResponse} + */ + + + setFuelLevel_State(level_state) { + this.validateType(VehicleDataResult, level_state); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getFuelLevel_State() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE); + } + /** + * @param {VehicleDataResult} consumption - The instantaneous fuel consumption in microlitres + * @return {UnsubscribeVehicleDataResponse} + */ + + + setInstantFuelConsumption(consumption) { + this.validateType(VehicleDataResult, consumption); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getInstantFuelConsumption() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION); + } + /** + * @param {VehicleDataResult} range - The estimate range in KM the vehicle can travel based on fuel level and + * consumption + * @return {UnsubscribeVehicleDataResponse} + */ + + + setFuelRange(range) { + this.validateType(VehicleDataResult, range); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE, range); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getFuelRange() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE); + } + /** + * @param {VehicleDataResult} temperature - The external temperature in degrees celsius + * @return {UnsubscribeVehicleDataResponse} + */ + + + setExternalTemperature(temperature) { + this.validateType(VehicleDataResult, temperature); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getExternalTemperature() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE); + } + /** + * @param {VehicleDataResult} signal - See TurnSignal + * @return {UnsubscribeVehicleDataResponse} + */ + + + setTurnSignal(signal) { + this.validateType(VehicleDataResult, signal); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL, signal); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getTurnSignal() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL); + } + /** + * @param {VehicleDataResult} prndl - See PRNDL + * @return {UnsubscribeVehicleDataResponse} + */ + + + setPrndl(prndl) { + this.validateType(VehicleDataResult, prndl); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_PRNDL, prndl); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getPrndl() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_PRNDL); + } + /** + * @param {VehicleDataResult} pressure - See TireStatus + * @return {UnsubscribeVehicleDataResponse} + */ + + + setTirePressure(pressure) { + this.validateType(VehicleDataResult, pressure); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE, pressure); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getTirePressure() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE); + } + /** + * @param {VehicleDataResult} odometer - Odometer in km + * @return {UnsubscribeVehicleDataResponse} + */ + + + setOdometer(odometer) { + this.validateType(VehicleDataResult, odometer); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ODOMETER, odometer); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getOdometer() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ODOMETER); + } + /** + * @param {VehicleDataResult} status - The status of the seat belts + * @return {UnsubscribeVehicleDataResponse} + */ + + + setBeltStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_BELT_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getBeltStatus() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_BELT_STATUS); + } + /** + * @param {VehicleDataResult} information - The body information including power modes + * @return {UnsubscribeVehicleDataResponse} + */ + + + setBodyInformation(information) { + this.validateType(VehicleDataResult, information); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION, information); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getBodyInformation() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION); + } + /** + * @param {VehicleDataResult} status - The device status including signal and battery strength + * @return {UnsubscribeVehicleDataResponse} + */ + + + setDeviceStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getDeviceStatus() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS); + } + /** + * @param {VehicleDataResult} braking - The status of the brake pedal + * @return {UnsubscribeVehicleDataResponse} + */ + + + setDriverBraking(braking) { + this.validateType(VehicleDataResult, braking); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING, braking); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getDriverBraking() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING); + } + /** + * @param {VehicleDataResult} status - The status of the wipers + * @return {UnsubscribeVehicleDataResponse} + */ + + + setWiperStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getWiperStatus() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS); + } + /** + * @param {VehicleDataResult} status - Status of the head lamps + * @return {UnsubscribeVehicleDataResponse} + */ + + + setHeadLampStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getHeadLampStatus() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS); + } + /** + * @param {VehicleDataResult} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {UnsubscribeVehicleDataResponse} + */ + + + setEngineTorque(torque) { + this.validateType(VehicleDataResult, torque); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE, torque); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getEngineTorque() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE); + } + /** + * @param {VehicleDataResult} position - Accelerator pedal position (percentage depressed) + * @return {UnsubscribeVehicleDataResponse} + */ + + + setAccPedalPosition(position) { + this.validateType(VehicleDataResult, position); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getAccPedalPosition() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION); + } + /** + * @param {VehicleDataResult} angle - Current angle of the steering wheel (in deg) + * @return {UnsubscribeVehicleDataResponse} + */ + + + setSteeringWheelAngle(angle) { + this.validateType(VehicleDataResult, angle); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getSteeringWheelAngle() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE); + } + /** + * @param {VehicleDataResult} life - The estimated percentage of remaining oil life of the engine. + * @return {UnsubscribeVehicleDataResponse} + */ + + + setEngineOilLife(life) { + this.validateType(VehicleDataResult, life); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getEngineOilLife() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE); + } + /** + * @param {VehicleDataResult} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {UnsubscribeVehicleDataResponse} + */ + + + setElectronicParkBrakeStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getElectronicParkBrakeStatus() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + /** + * @param {VehicleDataResult} id - Parameter used by cloud apps to identify a head unit + * @return {UnsubscribeVehicleDataResponse} + */ + + + setCloudAppVehicleID(id) { + this.validateType(VehicleDataResult, id); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getCloudAppVehicleID() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID); + } + /** + * @param {VehicleDataResult} info - Emergency Call notification and confirmation data + * @return {UnsubscribeVehicleDataResponse} + */ + + + setECallInfo(info) { + this.validateType(VehicleDataResult, info); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO, info); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getECallInfo() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO); + } + /** + * @param {VehicleDataResult} status - The status of the air bags + * @return {UnsubscribeVehicleDataResponse} + */ + + + setAirbagStatus(status) { + this.validateType(VehicleDataResult, status); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS, status); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getAirbagStatus() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS); + } + /** + * @param {VehicleDataResult} event - Information related to an emergency event (and if it occurred) + * @return {UnsubscribeVehicleDataResponse} + */ + + + setEmergencyEvent(event) { + this.validateType(VehicleDataResult, event); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT, event); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getEmergencyEvent() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT); + } + /** + * @param {VehicleDataResult} modes - The status modes of the cluster + * @return {UnsubscribeVehicleDataResponse} + */ + + + setClusterModes(modes) { + this.validateType(VehicleDataResult, modes); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES, modes); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getClusterModes() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES); + } + /** + * @param {VehicleDataResult} key - Information related to the MyKey feature + * @return {UnsubscribeVehicleDataResponse} + */ + + + setMyKey(key) { + this.validateType(VehicleDataResult, key); + this.setParameter(UnsubscribeVehicleDataResponse.KEY_MY_KEY, key); + return this; + } + /** + * @return {VehicleDataResult} + */ + + + getMyKey() { + return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_MY_KEY); + } + + } + + UnsubscribeVehicleDataResponse.KEY_GPS = 'gps'; + UnsubscribeVehicleDataResponse.KEY_SPEED = 'speed'; + UnsubscribeVehicleDataResponse.KEY_RPM = 'rpm'; + UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel'; + UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; + UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; + UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange'; + UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; + UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal'; + UnsubscribeVehicleDataResponse.KEY_PRNDL = 'prndl'; + UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure'; + UnsubscribeVehicleDataResponse.KEY_ODOMETER = 'odometer'; + UnsubscribeVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus'; + UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation'; + UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus'; + UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking'; + UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus'; + UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; + UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque'; + UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; + UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; + UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; + UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; + UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; + UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo'; + UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus'; + UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent'; + UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES = 'clusterModes'; + UnsubscribeVehicleDataResponse.KEY_MY_KEY = 'myKey'; + + /* eslint-disable camelcase */ + /** + * Non periodic vehicle data read request. + */ + + class GetVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetVehicleData); + } + /** + * @param {Boolean} gps - See GPSData + * @return {GetVehicleData} + */ + + + setGps(gps) { + this.setParameter(GetVehicleData.KEY_GPS, gps); + return this; + } + /** + * @return {Boolean} + */ + + + getGps() { + return this.getParameter(GetVehicleData.KEY_GPS); + } + /** + * @param {Boolean} speed - The vehicle speed in kilometers per hour + * @return {GetVehicleData} + */ + + + setSpeed(speed) { + this.setParameter(GetVehicleData.KEY_SPEED, speed); + return this; + } + /** + * @return {Boolean} + */ + + + getSpeed() { + return this.getParameter(GetVehicleData.KEY_SPEED); + } + /** + * @param {Boolean} rpm - The number of revolutions per minute of the engine + * @return {GetVehicleData} + */ + + + setRpm(rpm) { + this.setParameter(GetVehicleData.KEY_RPM, rpm); + return this; + } + /** + * @return {Boolean} + */ + + + getRpm() { + return this.getParameter(GetVehicleData.KEY_RPM); + } + /** + * @param {Boolean} level - The fuel level in the tank (percentage) + * @return {GetVehicleData} + */ + + + setFuelLevel(level) { + this.setParameter(GetVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelLevel() { + return this.getParameter(GetVehicleData.KEY_FUEL_LEVEL); + } + /** + * @param {Boolean} level_state - The fuel level state + * @return {GetVehicleData} + */ + + + setFuelLevel_State(level_state) { + this.setParameter(GetVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelLevel_State() { + return this.getParameter(GetVehicleData.KEY_FUEL_LEVEL_STATE); + } + /** + * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres + * @return {GetVehicleData} + */ + + + setInstantFuelConsumption(consumption) { + this.setParameter(GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + /** + * @return {Boolean} + */ + + + getInstantFuelConsumption() { + return this.getParameter(GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + /** + * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {GetVehicleData} + */ + + + setFuelRange(range) { + this.setParameter(GetVehicleData.KEY_FUEL_RANGE, range); + return this; + } + /** + * @return {Boolean} + */ + + + getFuelRange() { + return this.getParameter(GetVehicleData.KEY_FUEL_RANGE); + } + /** + * @param {Boolean} temperature - The external temperature in degrees celsius + * @return {GetVehicleData} + */ + + + setExternalTemperature(temperature) { + this.setParameter(GetVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + /** + * @return {Boolean} + */ + + + getExternalTemperature() { + return this.getParameter(GetVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + /** + * @param {Boolean} signal - See TurnSignal + * @return {GetVehicleData} + */ + + + setTurnSignal(signal) { + this.setParameter(GetVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + /** + * @return {Boolean} + */ + + + getTurnSignal() { + return this.getParameter(GetVehicleData.KEY_TURN_SIGNAL); + } + /** + * @param {Boolean} vin - Vehicle identification number + * @return {GetVehicleData} + */ + + + setVin(vin) { + this.setParameter(GetVehicleData.KEY_VIN, vin); + return this; + } + /** + * @return {Boolean} + */ + + + getVin() { + return this.getParameter(GetVehicleData.KEY_VIN); + } + /** + * @param {Boolean} prndl - See PRNDL + * @return {GetVehicleData} + */ + + + setPrndl(prndl) { + this.setParameter(GetVehicleData.KEY_PRNDL, prndl); + return this; + } + /** + * @return {Boolean} + */ + + + getPrndl() { + return this.getParameter(GetVehicleData.KEY_PRNDL); + } + /** + * @param {Boolean} pressure - See TireStatus + * @return {GetVehicleData} + */ + + + setTirePressure(pressure) { + this.setParameter(GetVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + /** + * @return {Boolean} + */ + + + getTirePressure() { + return this.getParameter(GetVehicleData.KEY_TIRE_PRESSURE); + } + /** + * @param {Boolean} odometer - Odometer in km + * @return {GetVehicleData} + */ + + + setOdometer(odometer) { + this.setParameter(GetVehicleData.KEY_ODOMETER, odometer); + return this; + } + /** + * @return {Boolean} + */ + + + getOdometer() { + return this.getParameter(GetVehicleData.KEY_ODOMETER); + } + /** + * @param {Boolean} status - The status of the seat belts + * @return {GetVehicleData} + */ + + + setBeltStatus(status) { + this.setParameter(GetVehicleData.KEY_BELT_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getBeltStatus() { + return this.getParameter(GetVehicleData.KEY_BELT_STATUS); + } + /** + * @param {Boolean} information - The body information including ignition status and internal temp + * @return {GetVehicleData} + */ + + + setBodyInformation(information) { + this.setParameter(GetVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + /** + * @return {Boolean} + */ + + + getBodyInformation() { + return this.getParameter(GetVehicleData.KEY_BODY_INFORMATION); + } + /** + * @param {Boolean} status - The device status including signal and battery strength + * @return {GetVehicleData} + */ + + + setDeviceStatus(status) { + this.setParameter(GetVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getDeviceStatus() { + return this.getParameter(GetVehicleData.KEY_DEVICE_STATUS); + } + /** + * @param {Boolean} braking - The status of the brake pedal + * @return {GetVehicleData} + */ + + + setDriverBraking(braking) { + this.setParameter(GetVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + /** + * @return {Boolean} + */ + + + getDriverBraking() { + return this.getParameter(GetVehicleData.KEY_DRIVER_BRAKING); + } + /** + * @param {Boolean} status - The status of the wipers + * @return {GetVehicleData} + */ + + + setWiperStatus(status) { + this.setParameter(GetVehicleData.KEY_WIPER_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getWiperStatus() { + return this.getParameter(GetVehicleData.KEY_WIPER_STATUS); + } + /** + * @param {Boolean} status - Status of the head lamps + * @return {GetVehicleData} + */ + + + setHeadLampStatus(status) { + this.setParameter(GetVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getHeadLampStatus() { + return this.getParameter(GetVehicleData.KEY_HEAD_LAMP_STATUS); + } + /** + * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {GetVehicleData} + */ + + + setEngineTorque(torque) { + this.setParameter(GetVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + /** + * @return {Boolean} + */ + + + getEngineTorque() { + return this.getParameter(GetVehicleData.KEY_ENGINE_TORQUE); + } + /** + * @param {Boolean} position - Accelerator pedal position (percentage depressed) + * @return {GetVehicleData} + */ + + + setAccPedalPosition(position) { + this.setParameter(GetVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + /** + * @return {Boolean} + */ + + + getAccPedalPosition() { + return this.getParameter(GetVehicleData.KEY_ACC_PEDAL_POSITION); + } + /** + * @param {Boolean} angle - Current angle of the steering wheel (in deg) + * @return {GetVehicleData} + */ + + + setSteeringWheelAngle(angle) { + this.setParameter(GetVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + /** + * @return {Boolean} + */ + + + getSteeringWheelAngle() { + return this.getParameter(GetVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + /** + * @param {Boolean} life - The estimated percentage of remaining oil life of the engine. + * @return {GetVehicleData} + */ + + + setEngineOilLife(life) { + this.setParameter(GetVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + /** + * @return {Boolean} + */ + + + getEngineOilLife() { + return this.getParameter(GetVehicleData.KEY_ENGINE_OIL_LIFE); + } + /** + * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system. + * @return {GetVehicleData} + */ + + + setElectronicParkBrakeStatus(status) { + this.setParameter(GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getElectronicParkBrakeStatus() { + return this.getParameter(GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + /** + * @param {Boolean} id - Parameter used by cloud apps to identify a head unit + * @return {GetVehicleData} + */ + + + setCloudAppVehicleID(id) { + this.setParameter(GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + /** + * @return {Boolean} + */ + + + getCloudAppVehicleID() { + return this.getParameter(GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + /** + * @param {Boolean} info - Emergency Call notification and confirmation data + * @return {GetVehicleData} + */ + + + setECallInfo(info) { + this.setParameter(GetVehicleData.KEY_E_CALL_INFO, info); + return this; + } + /** + * @return {Boolean} + */ + + + getECallInfo() { + return this.getParameter(GetVehicleData.KEY_E_CALL_INFO); + } + /** + * @param {Boolean} status - The status of the air bags + * @return {GetVehicleData} + */ + + + setAirbagStatus(status) { + this.setParameter(GetVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getAirbagStatus() { + return this.getParameter(GetVehicleData.KEY_AIRBAG_STATUS); + } + /** + * @param {Boolean} event - Information related to an emergency event (and if it occurred) + * @return {GetVehicleData} + */ + + + setEmergencyEvent(event) { + this.setParameter(GetVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + /** + * @return {Boolean} + */ + + + getEmergencyEvent() { + return this.getParameter(GetVehicleData.KEY_EMERGENCY_EVENT); + } + /** + * @param {Boolean} status - The status modes of the cluster + * @return {GetVehicleData} + */ + + + setClusterModeStatus(status) { + this.setParameter(GetVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + /** + * @return {Boolean} + */ + + + getClusterModeStatus() { + return this.getParameter(GetVehicleData.KEY_CLUSTER_MODE_STATUS); + } + /** + * @param {Boolean} key - Information related to the MyKey feature + * @return {GetVehicleData} + */ + + + setMyKey(key) { + this.setParameter(GetVehicleData.KEY_MY_KEY, key); + return this; + } + /** + * @return {Boolean} + */ + + + getMyKey() { + return this.getParameter(GetVehicleData.KEY_MY_KEY); + } + + } + + GetVehicleData.KEY_GPS = 'gps'; + GetVehicleData.KEY_SPEED = 'speed'; + GetVehicleData.KEY_RPM = 'rpm'; + GetVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; + GetVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; + GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; + GetVehicleData.KEY_FUEL_RANGE = 'fuelRange'; + GetVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; + GetVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; + GetVehicleData.KEY_VIN = 'vin'; + GetVehicleData.KEY_PRNDL = 'prndl'; + GetVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; + GetVehicleData.KEY_ODOMETER = 'odometer'; + GetVehicleData.KEY_BELT_STATUS = 'beltStatus'; + GetVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; + GetVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; + GetVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; + GetVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; + GetVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; + GetVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; + GetVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; + GetVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; + GetVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; + GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; + GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; + GetVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; + GetVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; + GetVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; + GetVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; + GetVehicleData.KEY_MY_KEY = 'myKey'; + + /* eslint-disable camelcase */ + /** + * Reflects the status of a vehicle data event; e.g. a seat belt event status. + * @typedef {Enum} VehicleDataEventStatus + * @property {Object} _MAP + */ + + class VehicleDataEventStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get VDES_NO_EVENT() { + return VehicleDataEventStatus._MAP.VDES_NO_EVENT; + } + /** + * @return {String} + */ + + + static get VDES_NO() { + return VehicleDataEventStatus._MAP.VDES_NO; + } + /** + * @return {String} + */ + + + static get VDES_YES() { + return VehicleDataEventStatus._MAP.VDES_YES; + } + /** + * @return {String} + */ + + + static get VDES_NOT_SUPPORTED() { + return VehicleDataEventStatus._MAP.VDES_NOT_SUPPORTED; + } + /** + * @return {String} + */ + + + static get VDES_FAULT() { + return VehicleDataEventStatus._MAP.VDES_FAULT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VehicleDataEventStatus._valueForKey(key, VehicleDataEventStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VehicleDataEventStatus._keyForValue(value, VehicleDataEventStatus._MAP); + } + + } + + VehicleDataEventStatus._MAP = Object.freeze({ + 'VDES_NO_EVENT': 'NO_EVENT', + 'VDES_NO': 'NO', + 'VDES_YES': 'YES', + 'VDES_NOT_SUPPORTED': 'NOT_SUPPORTED', + 'VDES_FAULT': 'FAULT' + }); + + /* eslint-disable camelcase */ + + class AirbagStatus extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvBag_D_Ltchd". See VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setDriverAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvSideBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setDriverSideAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverSideAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvCrtnBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setDriverCurtainAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverCurtainAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasBag_D_Ltchd". See VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setPassengerAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getPassengerAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasCrtnBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setPassengerCurtainAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getPassengerCurtainAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsKneeDrvBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setDriverKneeAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverKneeAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasSideBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setPassengerSideAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getPassengerSideAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsKneePasBag_D_Ltchd". See + * VehicleDataEventStatus. + * @return {AirbagStatus} + */ + + + setPassengerKneeAirbagDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getPassengerKneeAirbagDeployed() { + return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED); + } + + } + + AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED = 'driverAirbagDeployed'; + AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED = 'driverSideAirbagDeployed'; + AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED = 'driverCurtainAirbagDeployed'; + AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED = 'passengerAirbagDeployed'; + AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED = 'passengerCurtainAirbagDeployed'; + AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED = 'driverKneeAirbagDeployed'; + AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED = 'passengerSideAirbagDeployed'; + AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED = 'passengerKneeAirbagDeployed'; + + /* eslint-disable camelcase */ + /** + * Reflects the status of the current power mode. + * @typedef {Enum} PowerModeStatus + * @property {Object} _MAP + */ + + class PowerModeStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get KEY_OUT() { + return PowerModeStatus._MAP.KEY_OUT; + } + /** + * @return {String} + */ + + + static get KEY_RECENTLY_OUT() { + return PowerModeStatus._MAP.KEY_RECENTLY_OUT; + } + /** + * @return {String} + */ + + + static get KEY_APPROVED_0() { + return PowerModeStatus._MAP.KEY_APPROVED_0; + } + /** + * @return {String} + */ + + + static get POST_ACCESORY_0() { + return PowerModeStatus._MAP.POST_ACCESORY_0; + } + /** + * @return {String} + */ + + + static get ACCESORY_1() { + return PowerModeStatus._MAP.ACCESORY_1; + } + /** + * @return {String} + */ + + + static get POST_IGNITION_1() { + return PowerModeStatus._MAP.POST_IGNITION_1; + } + /** + * @return {String} + */ + + + static get IGNITION_ON_2() { + return PowerModeStatus._MAP.IGNITION_ON_2; + } + /** + * @return {String} + */ + + + static get RUNNING_2() { + return PowerModeStatus._MAP.RUNNING_2; + } + /** + * @return {String} + */ + + + static get CRANK_3() { + return PowerModeStatus._MAP.CRANK_3; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return PowerModeStatus._valueForKey(key, PowerModeStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PowerModeStatus._keyForValue(value, PowerModeStatus._MAP); + } + + } + + PowerModeStatus._MAP = Object.freeze({ + 'KEY_OUT': 'KEY_OUT', + 'KEY_RECENTLY_OUT': 'KEY_RECENTLY_OUT', + 'KEY_APPROVED_0': 'KEY_APPROVED_0', + 'POST_ACCESORY_0': 'POST_ACCESORY_0', + 'ACCESORY_1': 'ACCESORY_1', + 'POST_IGNITION_1': 'POST_IGNITION_1', + 'IGNITION_ON_2': 'IGNITION_ON_2', + 'RUNNING_2': 'RUNNING_2', + 'CRANK_3': 'CRANK_3' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of the current car mode. + * @typedef {Enum} CarModeStatus + * @property {Object} _MAP + */ + + class CarModeStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get CMS_NORMAL() { + return CarModeStatus._MAP.CMS_NORMAL; + } + /** + * @return {String} + */ + + + static get CMS_FACTORY() { + return CarModeStatus._MAP.CMS_FACTORY; + } + /** + * @return {String} + */ + + + static get CMS_TRANSPORT() { + return CarModeStatus._MAP.CMS_TRANSPORT; + } + /** + * @return {String} + */ + + + static get CMS_CRASH() { + return CarModeStatus._MAP.CMS_CRASH; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return CarModeStatus._valueForKey(key, CarModeStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return CarModeStatus._keyForValue(value, CarModeStatus._MAP); + } + + } + + CarModeStatus._MAP = Object.freeze({ + 'CMS_NORMAL': 'NORMAL', + 'CMS_FACTORY': 'FACTORY', + 'CMS_TRANSPORT': 'TRANSPORT', + 'CMS_CRASH': 'CRASH' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of the current power mode qualification. + * @typedef {Enum} PowerModeQualificationStatus + * @property {Object} _MAP + */ + + class PowerModeQualificationStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get POWER_MODE_UNDEFINED() { + return PowerModeQualificationStatus._MAP.POWER_MODE_UNDEFINED; + } + /** + * @return {String} + */ + + + static get POWER_MODE_EVALUATION_IN_PROGRESS() { + return PowerModeQualificationStatus._MAP.POWER_MODE_EVALUATION_IN_PROGRESS; + } + /** + * @return {String} + */ + + + static get NOT_DEFINED() { + return PowerModeQualificationStatus._MAP.NOT_DEFINED; + } + /** + * @return {String} + */ + + + static get POWER_MODE_OK() { + return PowerModeQualificationStatus._MAP.POWER_MODE_OK; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return PowerModeQualificationStatus._valueForKey(key, PowerModeQualificationStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PowerModeQualificationStatus._keyForValue(value, PowerModeQualificationStatus._MAP); + } + + } + + PowerModeQualificationStatus._MAP = Object.freeze({ + 'POWER_MODE_UNDEFINED': 'POWER_MODE_UNDEFINED', + 'POWER_MODE_EVALUATION_IN_PROGRESS': 'POWER_MODE_EVALUATION_IN_PROGRESS', + 'NOT_DEFINED': 'NOT_DEFINED', + 'POWER_MODE_OK': 'POWER_MODE_OK' + }); + + /* eslint-disable camelcase */ + + class ClusterModeStatus extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} active - References signal "PowerMode_UB". + * @return {ClusterModeStatus} + */ + + + setPowerModeActive(active) { + this.setParameter(ClusterModeStatus.KEY_POWER_MODE_ACTIVE, active); + return this; + } + /** + * @return {Boolean} + */ + + + getPowerModeActive() { + return this.getParameter(ClusterModeStatus.KEY_POWER_MODE_ACTIVE); + } + /** + * @param {PowerModeQualificationStatus} status - References signal "PowerModeQF". See PowerModeQualificationStatus. + * @return {ClusterModeStatus} + */ + + + setPowerModeQualificationStatus(status) { + this.validateType(PowerModeQualificationStatus, status); + this.setParameter(ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS, status); + return this; + } + /** + * @return {PowerModeQualificationStatus} + */ + + + getPowerModeQualificationStatus() { + return this.getObject(PowerModeQualificationStatus, ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS); + } + /** + * @param {CarModeStatus} status - References signal "CarMode". See CarMode. + * @return {ClusterModeStatus} + */ + + + setCarModeStatus(status) { + this.validateType(CarModeStatus, status); + this.setParameter(ClusterModeStatus.KEY_CAR_MODE_STATUS, status); + return this; + } + /** + * @return {CarModeStatus} + */ + + + getCarModeStatus() { + return this.getObject(CarModeStatus, ClusterModeStatus.KEY_CAR_MODE_STATUS); + } + /** + * @param {PowerModeStatus} status - References signal "PowerMode". See PowerMode. + * @return {ClusterModeStatus} + */ + + + setPowerModeStatus(status) { + this.validateType(PowerModeStatus, status); + this.setParameter(ClusterModeStatus.KEY_POWER_MODE_STATUS, status); + return this; + } + /** + * @return {PowerModeStatus} + */ + + + getPowerModeStatus() { + return this.getObject(PowerModeStatus, ClusterModeStatus.KEY_POWER_MODE_STATUS); + } + + } + + ClusterModeStatus.KEY_POWER_MODE_ACTIVE = 'powerModeActive'; + ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS = 'powerModeQualificationStatus'; + ClusterModeStatus.KEY_CAR_MODE_STATUS = 'carModeStatus'; + ClusterModeStatus.KEY_POWER_MODE_STATUS = 'powerModeStatus'; + + /* eslint-disable camelcase */ + /** + * Reflects the status of the RCM fuel cutoff. + * @typedef {Enum} FuelCutoffStatus + * @property {Object} _MAP + */ + + class FuelCutoffStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get FCS_TERMINATE_FUEL() { + return FuelCutoffStatus._MAP.FCS_TERMINATE_FUEL; + } + /** + * @return {String} + */ + + + static get FCS_NORMAL_OPERATION() { + return FuelCutoffStatus._MAP.FCS_NORMAL_OPERATION; + } + /** + * @return {String} + */ + + + static get FCS_FAULT() { + return FuelCutoffStatus._MAP.FCS_FAULT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return FuelCutoffStatus._valueForKey(key, FuelCutoffStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return FuelCutoffStatus._keyForValue(value, FuelCutoffStatus._MAP); + } + + } + + FuelCutoffStatus._MAP = Object.freeze({ + 'FCS_TERMINATE_FUEL': 'TERMINATE_FUEL', + 'FCS_NORMAL_OPERATION': 'NORMAL_OPERATION', + 'FCS_FAULT': 'FAULT' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the emergency event status of the vehicle. + * @typedef {Enum} EmergencyEventType + * @property {Object} _MAP + */ + + class EmergencyEventType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get EET_NO_EVENT() { + return EmergencyEventType._MAP.EET_NO_EVENT; + } + /** + * @return {String} + */ + + + static get EET_FRONTAL() { + return EmergencyEventType._MAP.EET_FRONTAL; + } + /** + * @return {String} + */ + + + static get EET_SIDE() { + return EmergencyEventType._MAP.EET_SIDE; + } + /** + * @return {String} + */ + + + static get EET_REAR() { + return EmergencyEventType._MAP.EET_REAR; + } + /** + * @return {String} + */ + + + static get EET_ROLLOVER() { + return EmergencyEventType._MAP.EET_ROLLOVER; + } + /** + * @return {String} + */ + + + static get EET_NOT_SUPPORTED() { + return EmergencyEventType._MAP.EET_NOT_SUPPORTED; + } + /** + * @return {String} + */ + + + static get EET_FAULT() { + return EmergencyEventType._MAP.EET_FAULT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return EmergencyEventType._valueForKey(key, EmergencyEventType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return EmergencyEventType._keyForValue(value, EmergencyEventType._MAP); + } + + } + + EmergencyEventType._MAP = Object.freeze({ + 'EET_NO_EVENT': 'NO_EVENT', + 'EET_FRONTAL': 'FRONTAL', + 'EET_SIDE': 'SIDE', + 'EET_REAR': 'REAR', + 'EET_ROLLOVER': 'ROLLOVER', + 'EET_NOT_SUPPORTED': 'NOT_SUPPORTED', + 'EET_FAULT': 'FAULT' + }); + + /* eslint-disable camelcase */ + + class EmergencyEvent extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {EmergencyEventType} type - References signal "VedsEvntType_D_Ltchd". See EmergencyEventType. + * @return {EmergencyEvent} + */ + + + setEmergencyEventType(type) { + this.validateType(EmergencyEventType, type); + this.setParameter(EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE, type); + return this; + } + /** + * @return {EmergencyEventType} + */ + + + getEmergencyEventType() { + return this.getObject(EmergencyEventType, EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE); + } + /** + * @param {FuelCutoffStatus} status - References signal "RCM_FuelCutoff". See FuelCutoffStatus. + * @return {EmergencyEvent} + */ + + + setFuelCutoffStatus(status) { + this.validateType(FuelCutoffStatus, status); + this.setParameter(EmergencyEvent.KEY_FUEL_CUTOFF_STATUS, status); + return this; + } + /** + * @return {FuelCutoffStatus} + */ + + + getFuelCutoffStatus() { + return this.getObject(FuelCutoffStatus, EmergencyEvent.KEY_FUEL_CUTOFF_STATUS); + } + /** + * @param {VehicleDataEventStatus} event - References signal "VedsEvntRoll_D_Ltchd". See VehicleDataEventStatus. + * @return {EmergencyEvent} + */ + + + setRolloverEvent(event) { + this.validateType(VehicleDataEventStatus, event); + this.setParameter(EmergencyEvent.KEY_ROLLOVER_EVENT, event); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getRolloverEvent() { + return this.getObject(VehicleDataEventStatus, EmergencyEvent.KEY_ROLLOVER_EVENT); + } + /** + * @param {Number} velocity - References signal "VedsMaxDeltaV_D_Ltchd". Change in velocity in KPH. Additional + * reserved values: 0x00 No event 0xFE Not supported 0xFF Fault + * @return {EmergencyEvent} + */ + + + setMaximumChangeVelocity(velocity) { + this.setParameter(EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY, velocity); + return this; + } + /** + * @return {Number} + */ + + + getMaximumChangeVelocity() { + return this.getParameter(EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY); + } + /** + * @param {VehicleDataEventStatus} events - References signal "VedsMultiEvnt_D_Ltchd". See VehicleDataEventStatus. + * @return {EmergencyEvent} + */ + + + setMultipleEvents(events) { + this.validateType(VehicleDataEventStatus, events); + this.setParameter(EmergencyEvent.KEY_MULTIPLE_EVENTS, events); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getMultipleEvents() { + return this.getObject(VehicleDataEventStatus, EmergencyEvent.KEY_MULTIPLE_EVENTS); + } + + } + + EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE = 'emergencyEventType'; + EmergencyEvent.KEY_FUEL_CUTOFF_STATUS = 'fuelCutoffStatus'; + EmergencyEvent.KEY_ROLLOVER_EVENT = 'rolloverEvent'; + EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY = 'maximumChangeVelocity'; + EmergencyEvent.KEY_MULTIPLE_EVENTS = 'multipleEvents'; + + /* eslint-disable camelcase */ + /** + * Enumeration that describes the status of the turn light indicator. + * @typedef {Enum} TurnSignal + * @property {Object} _MAP + */ + + class TurnSignal extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Turn signal is OFF + * @return {String} + */ + + + static get OFF() { + return TurnSignal._MAP.OFF; + } + /** + * Left turn signal is on + * @return {String} + */ + + + static get LEFT() { + return TurnSignal._MAP.LEFT; + } + /** + * Right turn signal is on + * @return {String} + */ + + + static get RIGHT() { + return TurnSignal._MAP.RIGHT; + } + /** + * Both signals (left and right) are on. + * @return {String} + */ + + + static get BOTH() { + return TurnSignal._MAP.BOTH; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return TurnSignal._valueForKey(key, TurnSignal._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return TurnSignal._keyForValue(value, TurnSignal._MAP); + } + + } + + TurnSignal._MAP = Object.freeze({ + 'OFF': 'OFF', + 'LEFT': 'LEFT', + 'RIGHT': 'RIGHT', + 'BOTH': 'BOTH' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of the ambient light sensor. + * @typedef {Enum} AmbientLightStatus + * @property {Object} _MAP + */ + + class AmbientLightStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get NIGHT() { + return AmbientLightStatus._MAP.NIGHT; + } + /** + * @return {String} + */ + + + static get TWILIGHT_1() { + return AmbientLightStatus._MAP.TWILIGHT_1; + } + /** + * @return {String} + */ + + + static get TWILIGHT_2() { + return AmbientLightStatus._MAP.TWILIGHT_2; + } + /** + * @return {String} + */ + + + static get TWILIGHT_3() { + return AmbientLightStatus._MAP.TWILIGHT_3; + } + /** + * @return {String} + */ + + + static get TWILIGHT_4() { + return AmbientLightStatus._MAP.TWILIGHT_4; + } + /** + * @return {String} + */ + + + static get DAY() { + return AmbientLightStatus._MAP.DAY; + } + /** + * @return {String} + */ + + + static get ALS_UNKNOWN() { + return AmbientLightStatus._MAP.ALS_UNKNOWN; + } + /** + * @return {String} + */ + + + static get INVALID() { + return AmbientLightStatus._MAP.INVALID; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return AmbientLightStatus._valueForKey(key, AmbientLightStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return AmbientLightStatus._keyForValue(value, AmbientLightStatus._MAP); + } + + } + + AmbientLightStatus._MAP = Object.freeze({ + 'NIGHT': 'NIGHT', + 'TWILIGHT_1': 'TWILIGHT_1', + 'TWILIGHT_2': 'TWILIGHT_2', + 'TWILIGHT_3': 'TWILIGHT_3', + 'TWILIGHT_4': 'TWILIGHT_4', + 'DAY': 'DAY', + 'ALS_UNKNOWN': 'UNKNOWN', + 'INVALID': 'INVALID' + }); + + /* eslint-disable camelcase */ + + class HeadLampStatus extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} on - Status of the low beam lamps. References signal "HeadLampLoActv_B_Stat". + * @return {HeadLampStatus} + */ + + + setLowBeamsOn(on) { + this.setParameter(HeadLampStatus.KEY_LOW_BEAMS_ON, on); + return this; + } + /** + * @return {Boolean} + */ + + + getLowBeamsOn() { + return this.getParameter(HeadLampStatus.KEY_LOW_BEAMS_ON); + } + /** + * @param {Boolean} on - Status of the high beam lamps. References signal "HeadLghtHiOn_B_Stat". + * @return {HeadLampStatus} + */ + + + setHighBeamsOn(on) { + this.setParameter(HeadLampStatus.KEY_HIGH_BEAMS_ON, on); + return this; + } + /** + * @return {Boolean} + */ + + + getHighBeamsOn() { + return this.getParameter(HeadLampStatus.KEY_HIGH_BEAMS_ON); + } + /** + * @param {AmbientLightStatus} status - Status of the ambient light sensor. + * @return {HeadLampStatus} + */ + + + setAmbientLightSensorStatus(status) { + this.validateType(AmbientLightStatus, status); + this.setParameter(HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS, status); + return this; + } + /** + * @return {AmbientLightStatus} + */ + + + getAmbientLightSensorStatus() { + return this.getObject(AmbientLightStatus, HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS); + } + + } + + HeadLampStatus.KEY_LOW_BEAMS_ON = 'lowBeamsOn'; + HeadLampStatus.KEY_HIGH_BEAMS_ON = 'highBeamsOn'; + HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS = 'ambientLightSensorStatus'; + + /* eslint-disable camelcase */ + /** + * Reflects the current primary audio source (if selected). + * @typedef {Enum} PrimaryAudioSource + * @property {Object} _MAP + */ + + class PrimaryAudioSource extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get NO_SOURCE_SELECTED() { + return PrimaryAudioSource._MAP.NO_SOURCE_SELECTED; + } + /** + * @return {String} + */ + + + static get CD() { + return PrimaryAudioSource._MAP.CD; + } + /** + * @return {String} + */ + + + static get USB() { + return PrimaryAudioSource._MAP.USB; + } + /** + * @return {String} + */ + + + static get USB2() { + return PrimaryAudioSource._MAP.USB2; + } + /** + * @return {String} + */ + + + static get BLUETOOTH_STEREO_BTST() { + return PrimaryAudioSource._MAP.BLUETOOTH_STEREO_BTST; + } + /** + * @return {String} + */ + + + static get LINE_IN() { + return PrimaryAudioSource._MAP.LINE_IN; + } + /** + * @return {String} + */ + + + static get IPOD() { + return PrimaryAudioSource._MAP.IPOD; + } + /** + * @return {String} + */ + + + static get MOBILE_APP() { + return PrimaryAudioSource._MAP.MOBILE_APP; + } + /** + * @return {String} + */ + + + static get AM() { + return PrimaryAudioSource._MAP.AM; + } + /** + * @return {String} + */ + + + static get FM() { + return PrimaryAudioSource._MAP.FM; + } + /** + * @return {String} + */ + + + static get XM() { + return PrimaryAudioSource._MAP.XM; + } + /** + * @return {String} + */ + + + static get DAB() { + return PrimaryAudioSource._MAP.DAB; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return PrimaryAudioSource._valueForKey(key, PrimaryAudioSource._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PrimaryAudioSource._keyForValue(value, PrimaryAudioSource._MAP); + } + + } + + PrimaryAudioSource._MAP = Object.freeze({ + 'NO_SOURCE_SELECTED': 'NO_SOURCE_SELECTED', + 'CD': 'CD', + 'USB': 'USB', + 'USB2': 'USB2', + 'BLUETOOTH_STEREO_BTST': 'BLUETOOTH_STEREO_BTST', + 'LINE_IN': 'LINE_IN', + 'IPOD': 'IPOD', + 'MOBILE_APP': 'MOBILE_APP', + 'AM': 'AM', + 'FM': 'FM', + 'XM': 'XM', + 'DAB': 'DAB' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the reported battery status of the connected device, if reported. + * @typedef {Enum} DeviceLevelStatus + * @property {Object} _MAP + */ + + class DeviceLevelStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get ZERO_LEVEL_BARS() { + return DeviceLevelStatus._MAP.ZERO_LEVEL_BARS; + } + /** + * @return {String} + */ + + + static get ONE_LEVEL_BARS() { + return DeviceLevelStatus._MAP.ONE_LEVEL_BARS; + } + /** + * @return {String} + */ + + + static get TWO_LEVEL_BARS() { + return DeviceLevelStatus._MAP.TWO_LEVEL_BARS; + } + /** + * @return {String} + */ + + + static get THREE_LEVEL_BARS() { + return DeviceLevelStatus._MAP.THREE_LEVEL_BARS; + } + /** + * @return {String} + */ + + + static get FOUR_LEVEL_BARS() { + return DeviceLevelStatus._MAP.FOUR_LEVEL_BARS; + } + /** + * @return {String} + */ + + + static get NOT_PROVIDED() { + return DeviceLevelStatus._MAP.NOT_PROVIDED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return DeviceLevelStatus._valueForKey(key, DeviceLevelStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return DeviceLevelStatus._keyForValue(value, DeviceLevelStatus._MAP); + } + + } + + DeviceLevelStatus._MAP = Object.freeze({ + 'ZERO_LEVEL_BARS': 'ZERO_LEVEL_BARS', + 'ONE_LEVEL_BARS': 'ONE_LEVEL_BARS', + 'TWO_LEVEL_BARS': 'TWO_LEVEL_BARS', + 'THREE_LEVEL_BARS': 'THREE_LEVEL_BARS', + 'FOUR_LEVEL_BARS': 'FOUR_LEVEL_BARS', + 'NOT_PROVIDED': 'NOT_PROVIDED' + }); + + /* eslint-disable camelcase */ + + class DeviceStatus extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} on - References signal "CPM_VoiceRec_STAT". + * @return {DeviceStatus} + */ + + + setVoiceRecOn(on) { + this.setParameter(DeviceStatus.KEY_VOICE_REC_ON, on); + return this; + } + /** + * @return {Boolean} + */ + + + getVoiceRecOn() { + return this.getParameter(DeviceStatus.KEY_VOICE_REC_ON); + } + /** + * @param {Boolean} on - References signal "BT_ICON". + * @return {DeviceStatus} + */ + + + setBtIconOn(on) { + this.setParameter(DeviceStatus.KEY_BT_ICON_ON, on); + return this; + } + /** + * @return {Boolean} + */ + + + getBtIconOn() { + return this.getParameter(DeviceStatus.KEY_BT_ICON_ON); + } + /** + * @param {Boolean} active - References signal "CPM_Call_Active_STAT". + * @return {DeviceStatus} + */ + + + setCallActive(active) { + this.setParameter(DeviceStatus.KEY_CALL_ACTIVE, active); + return this; + } + /** + * @return {Boolean} + */ + + + getCallActive() { + return this.getParameter(DeviceStatus.KEY_CALL_ACTIVE); + } + /** + * @param {Boolean} roaming - References signal "CPM_Phone_Roaming_STAT". + * @return {DeviceStatus} + */ + + + setPhoneRoaming(roaming) { + this.setParameter(DeviceStatus.KEY_PHONE_ROAMING, roaming); + return this; + } + /** + * @return {Boolean} + */ + + + getPhoneRoaming() { + return this.getParameter(DeviceStatus.KEY_PHONE_ROAMING); + } + /** + * @param {Boolean} available - References signal "CPM_TextMsg_AVAL". + * @return {DeviceStatus} + */ + + + setTextMsgAvailable(available) { + this.setParameter(DeviceStatus.KEY_TEXT_MSG_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getTextMsgAvailable() { + return this.getParameter(DeviceStatus.KEY_TEXT_MSG_AVAILABLE); + } + /** + * @param {DeviceLevelStatus} status - Device battery level status. References signal "CPM_Batt_Level_STAT". See + * DeviceLevelStatus. + * @return {DeviceStatus} + */ + + + setBattLevelStatus(status) { + this.validateType(DeviceLevelStatus, status); + this.setParameter(DeviceStatus.KEY_BATT_LEVEL_STATUS, status); + return this; + } + /** + * @return {DeviceLevelStatus} + */ + + + getBattLevelStatus() { + return this.getObject(DeviceLevelStatus, DeviceStatus.KEY_BATT_LEVEL_STATUS); + } + /** + * @param {Boolean} muted - References signal "CPM_Stereo_Audio_Output". + * @return {DeviceStatus} + */ + + + setStereoAudioOutputMuted(muted) { + this.setParameter(DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED, muted); + return this; + } + /** + * @return {Boolean} + */ + + + getStereoAudioOutputMuted() { + return this.getParameter(DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED); + } + /** + * @param {Boolean} muted - References signal "CPM_Mono_Audio_Output". + * @return {DeviceStatus} + */ + + + setMonoAudioOutputMuted(muted) { + this.setParameter(DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED, muted); + return this; + } + /** + * @return {Boolean} + */ + + + getMonoAudioOutputMuted() { + return this.getParameter(DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED); + } + /** + * @param {DeviceLevelStatus} status - Device signal level status. References signal "CPM_Signal_Strength_STAT". See + * DeviceLevelStatus. + * @return {DeviceStatus} + */ + + + setSignalLevelStatus(status) { + this.validateType(DeviceLevelStatus, status); + this.setParameter(DeviceStatus.KEY_SIGNAL_LEVEL_STATUS, status); + return this; + } + /** + * @return {DeviceLevelStatus} + */ + + + getSignalLevelStatus() { + return this.getObject(DeviceLevelStatus, DeviceStatus.KEY_SIGNAL_LEVEL_STATUS); + } + /** + * @param {PrimaryAudioSource} source - References signal "CPM_Stereo_PAS_Source". See PrimaryAudioSource. + * @return {DeviceStatus} + */ + + + setPrimaryAudioSource(source) { + this.validateType(PrimaryAudioSource, source); + this.setParameter(DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE, source); + return this; + } + /** + * @return {PrimaryAudioSource} + */ + + + getPrimaryAudioSource() { + return this.getObject(PrimaryAudioSource, DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE); + } + /** + * @param {Boolean} active - References signal "eCall_Event". + * @return {DeviceStatus} + */ + + + setECallEventActive(active) { + this.setParameter(DeviceStatus.KEY_E_CALL_EVENT_ACTIVE, active); + return this; + } + /** + * @return {Boolean} + */ + + + getECallEventActive() { + return this.getParameter(DeviceStatus.KEY_E_CALL_EVENT_ACTIVE); + } + + } + + DeviceStatus.KEY_VOICE_REC_ON = 'voiceRecOn'; + DeviceStatus.KEY_BT_ICON_ON = 'btIconOn'; + DeviceStatus.KEY_CALL_ACTIVE = 'callActive'; + DeviceStatus.KEY_PHONE_ROAMING = 'phoneRoaming'; + DeviceStatus.KEY_TEXT_MSG_AVAILABLE = 'textMsgAvailable'; + DeviceStatus.KEY_BATT_LEVEL_STATUS = 'battLevelStatus'; + DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED = 'stereoAudioOutputMuted'; + DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED = 'monoAudioOutputMuted'; + DeviceStatus.KEY_SIGNAL_LEVEL_STATUS = 'signalLevelStatus'; + DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE = 'primaryAudioSource'; + DeviceStatus.KEY_E_CALL_EVENT_ACTIVE = 'eCallEventActive'; + + /* eslint-disable camelcase */ + /** + * Reflects the status of the wipers. + * @typedef {Enum} WiperStatus + * @property {Object} _MAP + */ + + class WiperStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get OFF() { + return WiperStatus._MAP.OFF; + } + /** + * @return {String} + */ + + + static get AUTO_OFF() { + return WiperStatus._MAP.AUTO_OFF; + } + /** + * @return {String} + */ + + + static get OFF_MOVING() { + return WiperStatus._MAP.OFF_MOVING; + } + /** + * @return {String} + */ + + + static get MAN_INT_OFF() { + return WiperStatus._MAP.MAN_INT_OFF; + } + /** + * @return {String} + */ + + + static get MAN_INT_ON() { + return WiperStatus._MAP.MAN_INT_ON; + } + /** + * @return {String} + */ + + + static get MAN_LOW() { + return WiperStatus._MAP.MAN_LOW; + } + /** + * @return {String} + */ + + + static get MAN_HIGH() { + return WiperStatus._MAP.MAN_HIGH; + } + /** + * @return {String} + */ + + + static get MAN_FLICK() { + return WiperStatus._MAP.MAN_FLICK; + } + /** + * @return {String} + */ + + + static get WASH() { + return WiperStatus._MAP.WASH; + } + /** + * @return {String} + */ + + + static get AUTO_LOW() { + return WiperStatus._MAP.AUTO_LOW; + } + /** + * @return {String} + */ + + + static get AUTO_HIGH() { + return WiperStatus._MAP.AUTO_HIGH; + } + /** + * @return {String} + */ + + + static get COURTESYWIPE() { + return WiperStatus._MAP.COURTESYWIPE; + } + /** + * @return {String} + */ + + + static get AUTO_ADJUST() { + return WiperStatus._MAP.AUTO_ADJUST; + } + /** + * @return {String} + */ + + + static get STALLED() { + return WiperStatus._MAP.STALLED; + } + /** + * @return {String} + */ + + + static get NO_DATA_EXISTS() { + return WiperStatus._MAP.NO_DATA_EXISTS; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return WiperStatus._valueForKey(key, WiperStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return WiperStatus._keyForValue(value, WiperStatus._MAP); + } + + } + + WiperStatus._MAP = Object.freeze({ + 'OFF': 'OFF', + 'AUTO_OFF': 'AUTO_OFF', + 'OFF_MOVING': 'OFF_MOVING', + 'MAN_INT_OFF': 'MAN_INT_OFF', + 'MAN_INT_ON': 'MAN_INT_ON', + 'MAN_LOW': 'MAN_LOW', + 'MAN_HIGH': 'MAN_HIGH', + 'MAN_FLICK': 'MAN_FLICK', + 'WASH': 'WASH', + 'AUTO_LOW': 'AUTO_LOW', + 'AUTO_HIGH': 'AUTO_HIGH', + 'COURTESYWIPE': 'COURTESYWIPE', + 'AUTO_ADJUST': 'AUTO_ADJUST', + 'STALLED': 'STALLED', + 'NO_DATA_EXISTS': 'NO_DATA_EXISTS' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} ElectronicParkBrakeStatus + * @property {Object} _MAP + */ + + class ElectronicParkBrakeStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Park brake actuators have been fully applied. + * @return {String} + */ + + + static get CLOSED() { + return ElectronicParkBrakeStatus._MAP.CLOSED; + } + /** + * Park brake actuators are transitioning to either Apply/Closed or Release/Open state. + * @return {String} + */ + + + static get TRANSITION() { + return ElectronicParkBrakeStatus._MAP.TRANSITION; + } + /** + * Park brake actuators are released. + * @return {String} + */ + + + static get OPEN() { + return ElectronicParkBrakeStatus._MAP.OPEN; + } + /** + * When driver pulls the Electronic Park Brake switch while driving "at speed". + * @return {String} + */ + + + static get DRIVE_ACTIVE() { + return ElectronicParkBrakeStatus._MAP.DRIVE_ACTIVE; + } + /** + * When system has a fault or is under maintenance. + * @return {String} + */ + + + static get FAULT() { + return ElectronicParkBrakeStatus._MAP.FAULT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ElectronicParkBrakeStatus._valueForKey(key, ElectronicParkBrakeStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ElectronicParkBrakeStatus._keyForValue(value, ElectronicParkBrakeStatus._MAP); + } + + } + + ElectronicParkBrakeStatus._MAP = Object.freeze({ + 'CLOSED': 'CLOSED', + 'TRANSITION': 'TRANSITION', + 'OPEN': 'OPEN', + 'DRIVE_ACTIVE': 'DRIVE_ACTIVE', + 'FAULT': 'FAULT' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of a binary vehicle data item. + * @typedef {Enum} VehicleDataStatus + * @property {Object} _MAP + */ + + class VehicleDataStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get VDS_NO_DATA_EXISTS() { + return VehicleDataStatus._MAP.VDS_NO_DATA_EXISTS; + } + /** + * @return {String} + */ + + + static get VDS_OFF() { + return VehicleDataStatus._MAP.VDS_OFF; + } + /** + * @return {String} + */ + + + static get VDS_ON() { + return VehicleDataStatus._MAP.VDS_ON; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VehicleDataStatus._valueForKey(key, VehicleDataStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VehicleDataStatus._keyForValue(value, VehicleDataStatus._MAP); + } + + } + + VehicleDataStatus._MAP = Object.freeze({ + 'VDS_NO_DATA_EXISTS': 'NO_DATA_EXISTS', + 'VDS_OFF': 'OFF', + 'VDS_ON': 'ON' + }); + + /* eslint-disable camelcase */ + + class MyKey extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {VehicleDataStatus} e911override - Indicates whether e911 override is on. References signal + * "MyKey_e911Override_St". See VehicleDataStatus. + * @return {MyKey} + */ + + + setE911Override(e911override) { + this.validateType(VehicleDataStatus, e911override); + this.setParameter(MyKey.KEY_E911OVERRIDE, e911override); + return this; + } + /** + * @return {VehicleDataStatus} + */ + + + getE911Override() { + return this.getObject(VehicleDataStatus, MyKey.KEY_E911OVERRIDE); + } + + } + + MyKey.KEY_E911OVERRIDE = 'e911Override'; + + /* eslint-disable camelcase */ + /** + * The list of potential compass directions + * @typedef {Enum} CompassDirection + * @property {Object} _MAP + */ + + class CompassDirection extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get NORTH() { + return CompassDirection._MAP.NORTH; + } + /** + * @return {String} + */ + + + static get NORTHWEST() { + return CompassDirection._MAP.NORTHWEST; + } + /** + * @return {String} + */ + + + static get WEST() { + return CompassDirection._MAP.WEST; + } + /** + * @return {String} + */ + + + static get SOUTHWEST() { + return CompassDirection._MAP.SOUTHWEST; + } + /** + * @return {String} + */ + + + static get SOUTH() { + return CompassDirection._MAP.SOUTH; + } + /** + * @return {String} + */ + + + static get SOUTHEAST() { + return CompassDirection._MAP.SOUTHEAST; + } + /** + * @return {String} + */ + + + static get EAST() { + return CompassDirection._MAP.EAST; + } + /** + * @return {String} + */ + + + static get NORTHEAST() { + return CompassDirection._MAP.NORTHEAST; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return CompassDirection._valueForKey(key, CompassDirection._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return CompassDirection._keyForValue(value, CompassDirection._MAP); + } + + } + + CompassDirection._MAP = Object.freeze({ + 'NORTH': 'NORTH', + 'NORTHWEST': 'NORTHWEST', + 'WEST': 'WEST', + 'SOUTHWEST': 'SOUTHWEST', + 'SOUTH': 'SOUTH', + 'SOUTHEAST': 'SOUTHEAST', + 'EAST': 'EAST', + 'NORTHEAST': 'NORTHEAST' + }); + + /* eslint-disable camelcase */ + /** + * The supported dimensions of the GPS + * @typedef {Enum} Dimension + * @property {Object} _MAP + */ + + class Dimension extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * No GPS at all + * @return {String} + */ + + + static get Dimension_NO_FIX() { + return Dimension._MAP.Dimension_NO_FIX; + } + /** + * Longitude and latitude + * @return {String} + */ + + + static get Dimension_2D() { + return Dimension._MAP.Dimension_2D; + } + /** + * Longitude and latitude and altitude + * @return {String} + */ + + + static get Dimension_3D() { + return Dimension._MAP.Dimension_3D; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return Dimension._valueForKey(key, Dimension._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return Dimension._keyForValue(value, Dimension._MAP); + } + + } + + Dimension._MAP = Object.freeze({ + 'Dimension_NO_FIX': 'NO_FIX', + 'Dimension_2D': '2D', + 'Dimension_3D': '3D' + }); + + /* eslint-disable camelcase */ + /** + * Struct with the GPS data. + */ + + class GPSData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} degrees + * @return {GPSData} + */ + + + setLongitudeDegrees(degrees) { + this.setParameter(GPSData.KEY_LONGITUDE_DEGREES, degrees); + return this; + } + /** + * @return {Number} + */ + + + getLongitudeDegrees() { + return this.getParameter(GPSData.KEY_LONGITUDE_DEGREES); + } + /** + * @param {Number} degrees + * @return {GPSData} + */ + + + setLatitudeDegrees(degrees) { + this.setParameter(GPSData.KEY_LATITUDE_DEGREES, degrees); + return this; + } + /** + * @return {Number} + */ + + + getLatitudeDegrees() { + return this.getParameter(GPSData.KEY_LATITUDE_DEGREES); + } + /** + * @param {Number} year - The current UTC year. + * @return {GPSData} + */ + + + setUtcYear(year) { + this.setParameter(GPSData.KEY_UTC_YEAR, year); + return this; + } + /** + * @return {Number} + */ + + + getUtcYear() { + return this.getParameter(GPSData.KEY_UTC_YEAR); + } + /** + * @param {Number} month - The current UTC month. + * @return {GPSData} + */ + + + setUtcMonth(month) { + this.setParameter(GPSData.KEY_UTC_MONTH, month); + return this; + } + /** + * @return {Number} + */ + + + getUtcMonth() { + return this.getParameter(GPSData.KEY_UTC_MONTH); + } + /** + * @param {Number} day - The current UTC day. + * @return {GPSData} + */ + + + setUtcDay(day) { + this.setParameter(GPSData.KEY_UTC_DAY, day); + return this; + } + /** + * @return {Number} + */ + + + getUtcDay() { + return this.getParameter(GPSData.KEY_UTC_DAY); + } + /** + * @param {Number} hours - The current UTC hour. + * @return {GPSData} + */ + + + setUtcHours(hours) { + this.setParameter(GPSData.KEY_UTC_HOURS, hours); + return this; + } + /** + * @return {Number} + */ + + + getUtcHours() { + return this.getParameter(GPSData.KEY_UTC_HOURS); + } + /** + * @param {Number} minutes - The current UTC minute. + * @return {GPSData} + */ + + + setUtcMinutes(minutes) { + this.setParameter(GPSData.KEY_UTC_MINUTES, minutes); + return this; + } + /** + * @return {Number} + */ + + + getUtcMinutes() { + return this.getParameter(GPSData.KEY_UTC_MINUTES); + } + /** + * @param {Number} seconds - The current UTC second. + * @return {GPSData} + */ + + + setUtcSeconds(seconds) { + this.setParameter(GPSData.KEY_UTC_SECONDS, seconds); + return this; + } + /** + * @return {Number} + */ + + + getUtcSeconds() { + return this.getParameter(GPSData.KEY_UTC_SECONDS); + } + /** + * @param {CompassDirection} direction - See CompassDirection. + * @return {GPSData} + */ + + + setCompassDirection(direction) { + this.validateType(CompassDirection, direction); + this.setParameter(GPSData.KEY_COMPASS_DIRECTION, direction); + return this; + } + /** + * @return {CompassDirection} + */ + + + getCompassDirection() { + return this.getObject(CompassDirection, GPSData.KEY_COMPASS_DIRECTION); + } + /** + * @param {Number} pdop - PDOP. If undefined or unavailable, then value shall be set to 0. + * @return {GPSData} + */ + + + setPdop(pdop) { + this.setParameter(GPSData.KEY_PDOP, pdop); + return this; + } + /** + * @return {Number} + */ + + + getPdop() { + return this.getParameter(GPSData.KEY_PDOP); + } + /** + * @param {Number} hdop - HDOP. If value is unknown, value shall be set to 0. + * @return {GPSData} + */ + + + setHdop(hdop) { + this.setParameter(GPSData.KEY_HDOP, hdop); + return this; + } + /** + * @return {Number} + */ + + + getHdop() { + return this.getParameter(GPSData.KEY_HDOP); + } + /** + * @param {Number} vdop - VDOP. If value is unknown, value shall be set to 0. + * @return {GPSData} + */ + + + setVdop(vdop) { + this.setParameter(GPSData.KEY_VDOP, vdop); + return this; + } + /** + * @return {Number} + */ + + + getVdop() { + return this.getParameter(GPSData.KEY_VDOP); + } + /** + * @param {Boolean} actual - True, if actual. False, if inferred. + * @return {GPSData} + */ + + + setActual(actual) { + this.setParameter(GPSData.KEY_ACTUAL, actual); + return this; + } + /** + * @return {Boolean} + */ + + + getActual() { + return this.getParameter(GPSData.KEY_ACTUAL); + } + /** + * @param {Number} satellites - Number of satellites in view + * @return {GPSData} + */ + + + setSatellites(satellites) { + this.setParameter(GPSData.KEY_SATELLITES, satellites); + return this; + } + /** + * @return {Number} + */ + + + getSatellites() { + return this.getParameter(GPSData.KEY_SATELLITES); + } + /** + * @param {Dimension} dimension - See Dimension + * @return {GPSData} + */ + + + setDimension(dimension) { + this.validateType(Dimension, dimension); + this.setParameter(GPSData.KEY_DIMENSION, dimension); + return this; + } + /** + * @return {Dimension} + */ + + + getDimension() { + return this.getObject(Dimension, GPSData.KEY_DIMENSION); + } + /** + * @param {Number} altitude - Altitude in meters + * @return {GPSData} + */ + + + setAltitude(altitude) { + this.setParameter(GPSData.KEY_ALTITUDE, altitude); + return this; + } + /** + * @return {Number} + */ + + + getAltitude() { + return this.getParameter(GPSData.KEY_ALTITUDE); + } + /** + * @param {Number} heading - The heading. North is 0. Resolution is 0.01 + * @return {GPSData} + */ + + + setHeading(heading) { + this.setParameter(GPSData.KEY_HEADING, heading); + return this; + } + /** + * @return {Number} + */ + + + getHeading() { + return this.getParameter(GPSData.KEY_HEADING); + } + /** + * @param {Number} speed - The speed in KPH + * @return {GPSData} + */ + + + setSpeed(speed) { + this.setParameter(GPSData.KEY_SPEED, speed); + return this; + } + /** + * @return {Number} + */ + + + getSpeed() { + return this.getParameter(GPSData.KEY_SPEED); + } + /** + * @param {Boolean} shifted - True, if GPS lat/long, time, and altitude have been purposefully shifted (requires a + * proprietary algorithm to unshift). False, if the GPS data is raw and un-shifted. If + * not provided, then value is assumed False. + * @return {GPSData} + */ + + + setShifted(shifted) { + this.setParameter(GPSData.KEY_SHIFTED, shifted); + return this; + } + /** + * @return {Boolean} + */ + + + getShifted() { + return this.getParameter(GPSData.KEY_SHIFTED); + } + + } + + GPSData.KEY_LONGITUDE_DEGREES = 'longitudeDegrees'; + GPSData.KEY_LATITUDE_DEGREES = 'latitudeDegrees'; + GPSData.KEY_UTC_YEAR = 'utcYear'; + GPSData.KEY_UTC_MONTH = 'utcMonth'; + GPSData.KEY_UTC_DAY = 'utcDay'; + GPSData.KEY_UTC_HOURS = 'utcHours'; + GPSData.KEY_UTC_MINUTES = 'utcMinutes'; + GPSData.KEY_UTC_SECONDS = 'utcSeconds'; + GPSData.KEY_COMPASS_DIRECTION = 'compassDirection'; + GPSData.KEY_PDOP = 'pdop'; + GPSData.KEY_HDOP = 'hdop'; + GPSData.KEY_VDOP = 'vdop'; + GPSData.KEY_ACTUAL = 'actual'; + GPSData.KEY_SATELLITES = 'satellites'; + GPSData.KEY_DIMENSION = 'dimension'; + GPSData.KEY_ALTITUDE = 'altitude'; + GPSData.KEY_HEADING = 'heading'; + GPSData.KEY_SPEED = 'speed'; + GPSData.KEY_SHIFTED = 'shifted'; + + /* eslint-disable camelcase */ + /** + * The selected gear. + * @typedef {Enum} PRNDL + * @property {Object} _MAP + */ + + class PRNDL extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Parking + * @return {String} + */ + + + static get PARK() { + return PRNDL._MAP.PARK; + } + /** + * Reverse gear + * @return {String} + */ + + + static get REVERSE() { + return PRNDL._MAP.REVERSE; + } + /** + * No gear + * @return {String} + */ + + + static get NEUTRAL() { + return PRNDL._MAP.NEUTRAL; + } + /** + * @return {String} + */ + + + static get DRIVE() { + return PRNDL._MAP.DRIVE; + } + /** + * Drive Sport mode + * @return {String} + */ + + + static get SPORT() { + return PRNDL._MAP.SPORT; + } + /** + * 1st gear hold + * @return {String} + */ + + + static get LOWGEAR() { + return PRNDL._MAP.LOWGEAR; + } + /** + * @return {String} + */ + + + static get FIRST() { + return PRNDL._MAP.FIRST; + } + /** + * @return {String} + */ + + + static get SECOND() { + return PRNDL._MAP.SECOND; + } + /** + * @return {String} + */ + + + static get THIRD() { + return PRNDL._MAP.THIRD; + } + /** + * @return {String} + */ + + + static get FOURTH() { + return PRNDL._MAP.FOURTH; + } + /** + * @return {String} + */ + + + static get FIFTH() { + return PRNDL._MAP.FIFTH; + } + /** + * @return {String} + */ + + + static get SIXTH() { + return PRNDL._MAP.SIXTH; + } + /** + * @return {String} + */ + + + static get SEVENTH() { + return PRNDL._MAP.SEVENTH; + } + /** + * @return {String} + */ + + + static get EIGHTH() { + return PRNDL._MAP.EIGHTH; + } + /** + * @return {String} + */ + + + static get UNKNOWN() { + return PRNDL._MAP.UNKNOWN; + } + /** + * @return {String} + */ + + + static get FAULT() { + return PRNDL._MAP.FAULT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return PRNDL._valueForKey(key, PRNDL._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PRNDL._keyForValue(value, PRNDL._MAP); + } + + } + + PRNDL._MAP = Object.freeze({ + 'PARK': 'PARK', + 'REVERSE': 'REVERSE', + 'NEUTRAL': 'NEUTRAL', + 'DRIVE': 'DRIVE', + 'SPORT': 'SPORT', + 'LOWGEAR': 'LOWGEAR', + 'FIRST': 'FIRST', + 'SECOND': 'SECOND', + 'THIRD': 'THIRD', + 'FOURTH': 'FOURTH', + 'FIFTH': 'FIFTH', + 'SIXTH': 'SIXTH', + 'SEVENTH': 'SEVENTH', + 'EIGHTH': 'EIGHTH', + 'UNKNOWN': 'UNKNOWN', + 'FAULT': 'FAULT' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} FuelType + * @property {Object} _MAP + */ + + class FuelType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get GASOLINE() { + return FuelType._MAP.GASOLINE; + } + /** + * @return {String} + */ + + + static get DIESEL() { + return FuelType._MAP.DIESEL; + } + /** + * For vehicles using compressed natural gas. + * @return {String} + */ + + + static get CNG() { + return FuelType._MAP.CNG; + } + /** + * For vehicles using liquefied petroleum gas. + * @return {String} + */ + + + static get LPG() { + return FuelType._MAP.LPG; + } + /** + * For FCEV (fuel cell electric vehicle). + * @return {String} + */ + + + static get HYDROGEN() { + return FuelType._MAP.HYDROGEN; + } + /** + * For BEV (Battery Electric Vehicle), PHEV (Plug-in Hybrid Electric Vehicle), solar vehicles and other vehicles + * which run on a battery. + * @return {String} + */ + + + static get BATTERY() { + return FuelType._MAP.BATTERY; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return FuelType._valueForKey(key, FuelType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return FuelType._keyForValue(value, FuelType._MAP); + } + + } + + FuelType._MAP = Object.freeze({ + 'GASOLINE': 'GASOLINE', + 'DIESEL': 'DIESEL', + 'CNG': 'CNG', + 'LPG': 'LPG', + 'HYDROGEN': 'HYDROGEN', + 'BATTERY': 'BATTERY' + }); + + /* eslint-disable camelcase */ + + class FuelRange extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {FuelType} type + * @return {FuelRange} + */ + + + setType(type) { + this.validateType(FuelType, type); + this.setParameter(FuelRange.KEY_TYPE, type); + return this; + } + /** + * @return {FuelType} + */ + + + getType() { + return this.getObject(FuelType, FuelRange.KEY_TYPE); + } + /** + * @param {Number} range - The estimate range in KM the vehicle can travel based on fuel level and consumption. + * @return {FuelRange} + */ + + + setRange(range) { + this.setParameter(FuelRange.KEY_RANGE, range); + return this; + } + /** + * @return {Number} + */ + + + getRange() { + return this.getParameter(FuelRange.KEY_RANGE); + } + + } + + FuelRange.KEY_TYPE = 'type'; + FuelRange.KEY_RANGE = 'range'; + + /* eslint-disable camelcase */ + /** + * Reflects the status of a vehicle data notification. + * @typedef {Enum} VehicleDataNotificationStatus + * @property {Object} _MAP + */ + + class VehicleDataNotificationStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get VDNS_NOT_SUPPORTED() { + return VehicleDataNotificationStatus._MAP.VDNS_NOT_SUPPORTED; + } + /** + * @return {String} + */ + + + static get VDNS_NORMAL() { + return VehicleDataNotificationStatus._MAP.VDNS_NORMAL; + } + /** + * @return {String} + */ + + + static get VDNS_ACTIVE() { + return VehicleDataNotificationStatus._MAP.VDNS_ACTIVE; + } + /** + * @return {String} + */ + + + static get VDNS_NOT_USED() { + return VehicleDataNotificationStatus._MAP.VDNS_NOT_USED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VehicleDataNotificationStatus._valueForKey(key, VehicleDataNotificationStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VehicleDataNotificationStatus._keyForValue(value, VehicleDataNotificationStatus._MAP); + } + + } + + VehicleDataNotificationStatus._MAP = Object.freeze({ + 'VDNS_NOT_SUPPORTED': 'NOT_SUPPORTED', + 'VDNS_NORMAL': 'NORMAL', + 'VDNS_ACTIVE': 'ACTIVE', + 'VDNS_NOT_USED': 'NOT_USED' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of the eCall Notification. + * @typedef {Enum} ECallConfirmationStatus + * @property {Object} _MAP + */ + + class ECallConfirmationStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get ECCS_NORMAL() { + return ECallConfirmationStatus._MAP.ECCS_NORMAL; + } + /** + * @return {String} + */ + + + static get ECCS_CALL_IN_PROGRESS() { + return ECallConfirmationStatus._MAP.ECCS_CALL_IN_PROGRESS; + } + /** + * @return {String} + */ + + + static get ECCS_CALL_CANCELLED() { + return ECallConfirmationStatus._MAP.ECCS_CALL_CANCELLED; + } + /** + * @return {String} + */ + + + static get CALL_COMPLETED() { + return ECallConfirmationStatus._MAP.CALL_COMPLETED; + } + /** + * @return {String} + */ + + + static get ECCS_CALL_UNSUCCESSFUL() { + return ECallConfirmationStatus._MAP.ECCS_CALL_UNSUCCESSFUL; + } + /** + * @return {String} + */ + + + static get ECCS_ECALL_CONFIGURED_OFF() { + return ECallConfirmationStatus._MAP.ECCS_ECALL_CONFIGURED_OFF; + } + /** + * @return {String} + */ + + + static get ECCS_CALL_COMPLETE_DTMF_TIMEOUT() { + return ECallConfirmationStatus._MAP.ECCS_CALL_COMPLETE_DTMF_TIMEOUT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ECallConfirmationStatus._valueForKey(key, ECallConfirmationStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ECallConfirmationStatus._keyForValue(value, ECallConfirmationStatus._MAP); + } + + } + + ECallConfirmationStatus._MAP = Object.freeze({ + 'ECCS_NORMAL': 'NORMAL', + 'ECCS_CALL_IN_PROGRESS': 'CALL_IN_PROGRESS', + 'ECCS_CALL_CANCELLED': 'CALL_CANCELLED', + 'CALL_COMPLETED': 'CALL_COMPLETED', + 'ECCS_CALL_UNSUCCESSFUL': 'CALL_UNSUCCESSFUL', + 'ECCS_ECALL_CONFIGURED_OFF': 'ECALL_CONFIGURED_OFF', + 'ECCS_CALL_COMPLETE_DTMF_TIMEOUT': 'CALL_COMPLETE_DTMF_TIMEOUT' + }); + + /* eslint-disable camelcase */ + + class ECallInfo extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {VehicleDataNotificationStatus} status - References signal "eCallNotification_4A". See + * VehicleDataNotificationStatus. + * @return {ECallInfo} + */ + + + setECallNotificationStatus(status) { + this.validateType(VehicleDataNotificationStatus, status); + this.setParameter(ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS, status); + return this; + } + /** + * @return {VehicleDataNotificationStatus} + */ + + + getECallNotificationStatus() { + return this.getObject(VehicleDataNotificationStatus, ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS); + } + /** + * @param {VehicleDataNotificationStatus} status - References signal "eCallNotification". See + * VehicleDataNotificationStatus. + * @return {ECallInfo} + */ + + + setAuxECallNotificationStatus(status) { + this.validateType(VehicleDataNotificationStatus, status); + this.setParameter(ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS, status); + return this; + } + /** + * @return {VehicleDataNotificationStatus} + */ + + + getAuxECallNotificationStatus() { + return this.getObject(VehicleDataNotificationStatus, ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS); + } + /** + * @param {ECallConfirmationStatus} status - References signal "eCallConfirmation". See ECallConfirmationStatus. + * @return {ECallInfo} + */ + + + setECallConfirmationStatus(status) { + this.validateType(ECallConfirmationStatus, status); + this.setParameter(ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS, status); + return this; + } + /** + * @return {ECallConfirmationStatus} + */ + + + getECallConfirmationStatus() { + return this.getObject(ECallConfirmationStatus, ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS); + } + + } + + ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS = 'eCallNotificationStatus'; + ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS = 'auxECallNotificationStatus'; + ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS = 'eCallConfirmationStatus'; + + /* eslint-disable camelcase */ + + class BeltStatus extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsDrvBelt_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setDriverBeltDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(BeltStatus.KEY_DRIVER_BELT_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverBeltDeployed() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_DRIVER_BELT_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsPasBelt_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setPassengerBeltDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(BeltStatus.KEY_PASSENGER_BELT_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getPassengerBeltDeployed() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_BELT_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw1PasBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setPassengerBuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_PASSENGER_BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getPassengerBuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw1DrvBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setDriverBuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_DRIVER_BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverBuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_DRIVER_BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2lBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setLeftRow2BuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getLeftRow2BuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} detected - References signal "VedsRw1PasChld_D_Ltchd". See + * VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setPassengerChildDetected(detected) { + this.validateType(VehicleDataEventStatus, detected); + this.setParameter(BeltStatus.KEY_PASSENGER_CHILD_DETECTED, detected); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getPassengerChildDetected() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_CHILD_DETECTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2rBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setRightRow2BuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getRightRow2BuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2mBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setMiddleRow2BuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getMiddleRow2BuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw3mBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setMiddleRow3BuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getMiddleRow3BuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw3lBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setLeftRow3BuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getLeftRow3BuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw3rBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setRightRow3BuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getRightRow3BuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2lRib_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setLeftRearInflatableBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getLeftRearInflatableBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw2rRib_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setRightRearInflatableBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getRightRearInflatableBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED); + } + /** + * @param {VehicleDataEventStatus} deployed - References signal "VedsRw1mBelt_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setMiddleRow1BeltDeployed(deployed) { + this.validateType(VehicleDataEventStatus, deployed); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED, deployed); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getMiddleRow1BeltDeployed() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED); + } + /** + * @param {VehicleDataEventStatus} belted - References signal "VedsRw1mBckl_D_Ltchd". See VehicleDataEventStatus. + * @return {BeltStatus} + */ + + + setMiddleRow1BuckleBelted(belted) { + this.validateType(VehicleDataEventStatus, belted); + this.setParameter(BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED, belted); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getMiddleRow1BuckleBelted() { + return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED); + } + + } + + BeltStatus.KEY_DRIVER_BELT_DEPLOYED = 'driverBeltDeployed'; + BeltStatus.KEY_PASSENGER_BELT_DEPLOYED = 'passengerBeltDeployed'; + BeltStatus.KEY_PASSENGER_BUCKLE_BELTED = 'passengerBuckleBelted'; + BeltStatus.KEY_DRIVER_BUCKLE_BELTED = 'driverBuckleBelted'; + BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED = 'leftRow2BuckleBelted'; + BeltStatus.KEY_PASSENGER_CHILD_DETECTED = 'passengerChildDetected'; + BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED = 'rightRow2BuckleBelted'; + BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED = 'middleRow2BuckleBelted'; + BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED = 'middleRow3BuckleBelted'; + BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED = 'leftRow3BuckleBelted'; + BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED = 'rightRow3BuckleBelted'; + BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED = 'leftRearInflatableBelted'; + BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED = 'rightRearInflatableBelted'; + BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED = 'middleRow1BeltDeployed'; + BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED = 'middleRow1BuckleBelted'; + + /* eslint-disable camelcase */ + /** + * The volume status of a vehicle component. + * @typedef {Enum} ComponentVolumeStatus + * @property {Object} _MAP + */ + + class ComponentVolumeStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get CVS_UNKNOWN() { + return ComponentVolumeStatus._MAP.CVS_UNKNOWN; + } + /** + * @return {String} + */ + + + static get CVS_NORMAL() { + return ComponentVolumeStatus._MAP.CVS_NORMAL; + } + /** + * @return {String} + */ + + + static get CVS_LOW() { + return ComponentVolumeStatus._MAP.CVS_LOW; + } + /** + * @return {String} + */ + + + static get CVS_FAULT() { + return ComponentVolumeStatus._MAP.CVS_FAULT; + } + /** + * @return {String} + */ + + + static get CVS_ALERT() { + return ComponentVolumeStatus._MAP.CVS_ALERT; + } + /** + * @return {String} + */ + + + static get CVS_NOT_SUPPORTED() { + return ComponentVolumeStatus._MAP.CVS_NOT_SUPPORTED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ComponentVolumeStatus._valueForKey(key, ComponentVolumeStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ComponentVolumeStatus._keyForValue(value, ComponentVolumeStatus._MAP); + } + + } + + ComponentVolumeStatus._MAP = Object.freeze({ + 'CVS_UNKNOWN': 'UNKNOWN', + 'CVS_NORMAL': 'NORMAL', + 'CVS_LOW': 'LOW', + 'CVS_FAULT': 'FAULT', + 'CVS_ALERT': 'ALERT', + 'CVS_NOT_SUPPORTED': 'NOT_SUPPORTED' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of ignition. + * @typedef {Enum} IgnitionStatus + * @property {Object} _MAP + */ + + class IgnitionStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get IS_UNKNOWN() { + return IgnitionStatus._MAP.IS_UNKNOWN; + } + /** + * @return {String} + */ + + + static get IS_OFF() { + return IgnitionStatus._MAP.IS_OFF; + } + /** + * @return {String} + */ + + + static get IS_ACCESSORY() { + return IgnitionStatus._MAP.IS_ACCESSORY; + } + /** + * @return {String} + */ + + + static get IS_RUN() { + return IgnitionStatus._MAP.IS_RUN; + } + /** + * @return {String} + */ + + + static get IS_START() { + return IgnitionStatus._MAP.IS_START; + } + /** + * @return {String} + */ + + + static get IS_INVALID() { + return IgnitionStatus._MAP.IS_INVALID; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return IgnitionStatus._valueForKey(key, IgnitionStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return IgnitionStatus._keyForValue(value, IgnitionStatus._MAP); + } + + } + + IgnitionStatus._MAP = Object.freeze({ + 'IS_UNKNOWN': 'UNKNOWN', + 'IS_OFF': 'OFF', + 'IS_ACCESSORY': 'ACCESSORY', + 'IS_RUN': 'RUN', + 'IS_START': 'START', + 'IS_INVALID': 'INVALID' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the ignition switch stability. + * @typedef {Enum} IgnitionStableStatus + * @property {Object} _MAP + */ + + class IgnitionStableStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get IGNITION_SWITCH_NOT_STABLE() { + return IgnitionStableStatus._MAP.IGNITION_SWITCH_NOT_STABLE; + } + /** + * @return {String} + */ + + + static get IGNITION_SWITCH_STABLE() { + return IgnitionStableStatus._MAP.IGNITION_SWITCH_STABLE; + } + /** + * @return {String} + */ + + + static get MISSING_FROM_TRANSMITTER() { + return IgnitionStableStatus._MAP.MISSING_FROM_TRANSMITTER; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return IgnitionStableStatus._valueForKey(key, IgnitionStableStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return IgnitionStableStatus._keyForValue(value, IgnitionStableStatus._MAP); + } + + } + + IgnitionStableStatus._MAP = Object.freeze({ + 'IGNITION_SWITCH_NOT_STABLE': 'IGNITION_SWITCH_NOT_STABLE', + 'IGNITION_SWITCH_STABLE': 'IGNITION_SWITCH_STABLE', + 'MISSING_FROM_TRANSMITTER': 'MISSING_FROM_TRANSMITTER' + }); + + /* eslint-disable camelcase */ + + class BodyInformation extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} active - References signal "PrkBrkActv_B_Actl". + * @return {BodyInformation} + */ + + + setParkBrakeActive(active) { + this.setParameter(BodyInformation.KEY_PARK_BRAKE_ACTIVE, active); + return this; + } + /** + * @return {Boolean} + */ + + + getParkBrakeActive() { + return this.getParameter(BodyInformation.KEY_PARK_BRAKE_ACTIVE); + } + /** + * @param {IgnitionStableStatus} status - References signal "Ignition_Switch_Stable". See IgnitionStableStatus. + * @return {BodyInformation} + */ + + + setIgnitionStableStatus(status) { + this.validateType(IgnitionStableStatus, status); + this.setParameter(BodyInformation.KEY_IGNITION_STABLE_STATUS, status); + return this; + } + /** + * @return {IgnitionStableStatus} + */ + + + getIgnitionStableStatus() { + return this.getObject(IgnitionStableStatus, BodyInformation.KEY_IGNITION_STABLE_STATUS); + } + /** + * @param {IgnitionStatus} status - References signal "Ignition_status". See IgnitionStatus. + * @return {BodyInformation} + */ + + + setIgnitionStatus(status) { + this.validateType(IgnitionStatus, status); + this.setParameter(BodyInformation.KEY_IGNITION_STATUS, status); + return this; + } + /** + * @return {IgnitionStatus} + */ + + + getIgnitionStatus() { + return this.getObject(IgnitionStatus, BodyInformation.KEY_IGNITION_STATUS); + } + /** + * @param {Boolean} ajar - References signal "DrStatDrv_B_Actl". + * @return {BodyInformation} + */ + + + setDriverDoorAjar(ajar) { + this.setParameter(BodyInformation.KEY_DRIVER_DOOR_AJAR, ajar); + return this; + } + /** + * @return {Boolean} + */ + + + getDriverDoorAjar() { + return this.getParameter(BodyInformation.KEY_DRIVER_DOOR_AJAR); + } + /** + * @param {Boolean} ajar - References signal "DrStatPsngr_B_Actl". + * @return {BodyInformation} + */ + + + setPassengerDoorAjar(ajar) { + this.setParameter(BodyInformation.KEY_PASSENGER_DOOR_AJAR, ajar); + return this; + } + /** + * @return {Boolean} + */ + + + getPassengerDoorAjar() { + return this.getParameter(BodyInformation.KEY_PASSENGER_DOOR_AJAR); + } + /** + * @param {Boolean} ajar - References signal "DrStatRl_B_Actl". + * @return {BodyInformation} + */ + + + setRearLeftDoorAjar(ajar) { + this.setParameter(BodyInformation.KEY_REAR_LEFT_DOOR_AJAR, ajar); + return this; + } + /** + * @return {Boolean} + */ + + + getRearLeftDoorAjar() { + return this.getParameter(BodyInformation.KEY_REAR_LEFT_DOOR_AJAR); + } + /** + * @param {Boolean} ajar - References signal "DrStatRr_B_Actl". + * @return {BodyInformation} + */ + + + setRearRightDoorAjar(ajar) { + this.setParameter(BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR, ajar); + return this; + } + /** + * @return {Boolean} + */ + + + getRearRightDoorAjar() { + return this.getParameter(BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR); + } + + } + + BodyInformation.KEY_PARK_BRAKE_ACTIVE = 'parkBrakeActive'; + BodyInformation.KEY_IGNITION_STABLE_STATUS = 'ignitionStableStatus'; + BodyInformation.KEY_IGNITION_STATUS = 'ignitionStatus'; + BodyInformation.KEY_DRIVER_DOOR_AJAR = 'driverDoorAjar'; + BodyInformation.KEY_PASSENGER_DOOR_AJAR = 'passengerDoorAjar'; + BodyInformation.KEY_REAR_LEFT_DOOR_AJAR = 'rearLeftDoorAjar'; + BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR = 'rearRightDoorAjar'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} TPMS + * @property {Object} _MAP + */ + + class TPMS extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * If set the status of the tire is not known. + * @return {String} + */ + + + static get UNKNOWN() { + return TPMS._MAP.UNKNOWN; + } + /** + * TPMS does not function. + * @return {String} + */ + + + static get SYSTEM_FAULT() { + return TPMS._MAP.SYSTEM_FAULT; + } + /** + * The sensor of the tire does not function. + * @return {String} + */ + + + static get SENSOR_FAULT() { + return TPMS._MAP.SENSOR_FAULT; + } + /** + * TPMS is reporting a low tire pressure for the tire. + * @return {String} + */ + + + static get LOW() { + return TPMS._MAP.LOW; + } + /** + * TPMS is active and the tire pressure is monitored. + * @return {String} + */ + + + static get SYSTEM_ACTIVE() { + return TPMS._MAP.SYSTEM_ACTIVE; + } + /** + * TPMS is reporting that the tire must be trained. + * @return {String} + */ + + + static get TRAIN() { + return TPMS._MAP.TRAIN; + } + /** + * TPMS reports the training for the tire is completed. + * @return {String} + */ + + + static get TRAINING_COMPLETE() { + return TPMS._MAP.TRAINING_COMPLETE; + } + /** + * TPMS reports the tire is not trained. + * @return {String} + */ + + + static get NOT_TRAINED() { + return TPMS._MAP.NOT_TRAINED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return TPMS._valueForKey(key, TPMS._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return TPMS._keyForValue(value, TPMS._MAP); + } + + } + + TPMS._MAP = Object.freeze({ + 'UNKNOWN': 'UNKNOWN', + 'SYSTEM_FAULT': 'SYSTEM_FAULT', + 'SENSOR_FAULT': 'SENSOR_FAULT', + 'LOW': 'LOW', + 'SYSTEM_ACTIVE': 'SYSTEM_ACTIVE', + 'TRAIN': 'TRAIN', + 'TRAINING_COMPLETE': 'TRAINING_COMPLETE', + 'NOT_TRAINED': 'NOT_TRAINED' + }); + + /* eslint-disable camelcase */ + + class SingleTireStatus extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {ComponentVolumeStatus} status - See ComponentVolumeStatus. + * @return {SingleTireStatus} + */ + + + setStatus(status) { + this.validateType(ComponentVolumeStatus, status); + this.setParameter(SingleTireStatus.KEY_STATUS, status); + return this; + } + /** + * @return {ComponentVolumeStatus} + */ + + + getStatus() { + return this.getObject(ComponentVolumeStatus, SingleTireStatus.KEY_STATUS); + } + /** + * @param {TPMS} tpms - The status of TPMS according to the particular tire. + * @return {SingleTireStatus} + */ + + + setTpms(tpms) { + this.validateType(TPMS, tpms); + this.setParameter(SingleTireStatus.KEY_TPMS, tpms); + return this; + } + /** + * @return {TPMS} + */ + + + getTpms() { + return this.getObject(TPMS, SingleTireStatus.KEY_TPMS); + } + /** + * @param {Number} pressure - The pressure value of the particular tire in kilo pascal. + * @return {SingleTireStatus} + */ + + + setPressure(pressure) { + this.setParameter(SingleTireStatus.KEY_PRESSURE, pressure); + return this; + } + /** + * @return {Number} + */ + + + getPressure() { + return this.getParameter(SingleTireStatus.KEY_PRESSURE); + } + + } + + SingleTireStatus.KEY_STATUS = 'status'; + SingleTireStatus.KEY_TPMS = 'tpms'; + SingleTireStatus.KEY_PRESSURE = 'pressure'; + + /* eslint-disable camelcase */ + /** + * Reflects the status of a cluster instrument warning light. + * @typedef {Enum} WarningLightStatus + * @property {Object} _MAP + */ + + class WarningLightStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get WLS_OFF() { + return WarningLightStatus._MAP.WLS_OFF; + } + /** + * @return {String} + */ + + + static get WLS_ON() { + return WarningLightStatus._MAP.WLS_ON; + } + /** + * @return {String} + */ + + + static get WLS_FLASH() { + return WarningLightStatus._MAP.WLS_FLASH; + } + /** + * @return {String} + */ + + + static get WLS_NOT_USED() { + return WarningLightStatus._MAP.WLS_NOT_USED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return WarningLightStatus._valueForKey(key, WarningLightStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return WarningLightStatus._keyForValue(value, WarningLightStatus._MAP); + } + + } + + WarningLightStatus._MAP = Object.freeze({ + 'WLS_OFF': 'OFF', + 'WLS_ON': 'ON', + 'WLS_FLASH': 'FLASH', + 'WLS_NOT_USED': 'NOT_USED' + }); + + /* eslint-disable camelcase */ + /** + * The status and pressure of the tires. + */ + + class TireStatus extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {WarningLightStatus} telltale - Status of the Tire Pressure Telltale. See WarningLightStatus. + * @return {TireStatus} + */ + + + setPressureTelltale(telltale) { + this.validateType(WarningLightStatus, telltale); + this.setParameter(TireStatus.KEY_PRESSURE_TELLTALE, telltale); + return this; + } + /** + * @return {WarningLightStatus} + */ + + + getPressureTelltale() { + return this.getObject(WarningLightStatus, TireStatus.KEY_PRESSURE_TELLTALE); + } + /** + * @param {SingleTireStatus} front - The status of the left front tire. + * @return {TireStatus} + */ + + + setLeftFront(front) { + this.validateType(SingleTireStatus, front); + this.setParameter(TireStatus.KEY_LEFT_FRONT, front); + return this; + } + /** + * @return {SingleTireStatus} + */ + + + getLeftFront() { + return this.getObject(SingleTireStatus, TireStatus.KEY_LEFT_FRONT); + } + /** + * @param {SingleTireStatus} front - The status of the right front tire. + * @return {TireStatus} + */ + + + setRightFront(front) { + this.validateType(SingleTireStatus, front); + this.setParameter(TireStatus.KEY_RIGHT_FRONT, front); + return this; + } + /** + * @return {SingleTireStatus} + */ + + + getRightFront() { + return this.getObject(SingleTireStatus, TireStatus.KEY_RIGHT_FRONT); + } + /** + * @param {SingleTireStatus} rear - The status of the left rear tire. + * @return {TireStatus} + */ + + + setLeftRear(rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_LEFT_REAR, rear); + return this; + } + /** + * @return {SingleTireStatus} + */ + + + getLeftRear() { + return this.getObject(SingleTireStatus, TireStatus.KEY_LEFT_REAR); + } + /** + * @param {SingleTireStatus} rear - The status of the right rear tire. + * @return {TireStatus} + */ + + + setRightRear(rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_RIGHT_REAR, rear); + return this; + } + /** + * @return {SingleTireStatus} + */ + + + getRightRear() { + return this.getObject(SingleTireStatus, TireStatus.KEY_RIGHT_REAR); + } + /** + * @param {SingleTireStatus} rear - The status of the inner left rear. + * @return {TireStatus} + */ + + + setInnerLeftRear(rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_INNER_LEFT_REAR, rear); + return this; + } + /** + * @return {SingleTireStatus} + */ + + + getInnerLeftRear() { + return this.getObject(SingleTireStatus, TireStatus.KEY_INNER_LEFT_REAR); + } + /** + * @param {SingleTireStatus} rear - The status of the inner right rear. + * @return {TireStatus} + */ + + + setInnerRightRear(rear) { + this.validateType(SingleTireStatus, rear); + this.setParameter(TireStatus.KEY_INNER_RIGHT_REAR, rear); + return this; + } + /** + * @return {SingleTireStatus} + */ + + + getInnerRightRear() { + return this.getObject(SingleTireStatus, TireStatus.KEY_INNER_RIGHT_REAR); + } + + } + + TireStatus.KEY_PRESSURE_TELLTALE = 'pressureTelltale'; + TireStatus.KEY_LEFT_FRONT = 'leftFront'; + TireStatus.KEY_RIGHT_FRONT = 'rightFront'; + TireStatus.KEY_LEFT_REAR = 'leftRear'; + TireStatus.KEY_RIGHT_REAR = 'rightRear'; + TireStatus.KEY_INNER_LEFT_REAR = 'innerLeftRear'; + TireStatus.KEY_INNER_RIGHT_REAR = 'innerRightRear'; + + /* eslint-disable camelcase */ + + class GetVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetVehicleData); + } + /** + * @param {GPSData} gps - See GPSData + * @return {GetVehicleDataResponse} + */ + + + setGps(gps) { + this.validateType(GPSData, gps); + this.setParameter(GetVehicleDataResponse.KEY_GPS, gps); + return this; + } + /** + * @return {GPSData} + */ + + + getGps() { + return this.getObject(GPSData, GetVehicleDataResponse.KEY_GPS); + } + /** + * @param {Number} speed - The vehicle speed in kilometers per hour + * @return {GetVehicleDataResponse} + */ + + + setSpeed(speed) { + this.setParameter(GetVehicleDataResponse.KEY_SPEED, speed); + return this; + } + /** + * @return {Number} + */ + + + getSpeed() { + return this.getParameter(GetVehicleDataResponse.KEY_SPEED); + } + /** + * @param {Number} rpm - The number of revolutions per minute of the engine + * @return {GetVehicleDataResponse} + */ + + + setRpm(rpm) { + this.setParameter(GetVehicleDataResponse.KEY_RPM, rpm); + return this; + } + /** + * @return {Number} + */ + + + getRpm() { + return this.getParameter(GetVehicleDataResponse.KEY_RPM); + } + /** + * @param {Number} level - The fuel level in the tank (percentage) + * @return {GetVehicleDataResponse} + */ + + + setFuelLevel(level) { + this.setParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL, level); + return this; + } + /** + * @return {Number} + */ + + + getFuelLevel() { + return this.getParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL); + } + /** + * @param {ComponentVolumeStatus} level_state - The fuel level state + * @return {GetVehicleDataResponse} + */ + + + setFuelLevel_State(level_state) { + this.validateType(ComponentVolumeStatus, level_state); + this.setParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + /** + * @return {ComponentVolumeStatus} + */ + + + getFuelLevel_State() { + return this.getObject(ComponentVolumeStatus, GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE); + } + /** + * @param {Number} consumption - The instantaneous fuel consumption in microlitres + * @return {GetVehicleDataResponse} + */ + + + setInstantFuelConsumption(consumption) { + this.setParameter(GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + /** + * @return {Number} + */ + + + getInstantFuelConsumption() { + return this.getParameter(GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION); + } + /** + * @param {FuelRange[]} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {GetVehicleDataResponse} + */ + + + setFuelRange(range) { + this.validateType(FuelRange, range, true); + this.setParameter(GetVehicleDataResponse.KEY_FUEL_RANGE, range); + return this; + } + /** + * @return {FuelRange[]} + */ + + + getFuelRange() { + return this.getObject(FuelRange, GetVehicleDataResponse.KEY_FUEL_RANGE); + } + /** + * @param {Number} temperature - The external temperature in degrees celsius + * @return {GetVehicleDataResponse} + */ + + + setExternalTemperature(temperature) { + this.setParameter(GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + /** + * @return {Number} + */ + + + getExternalTemperature() { + return this.getParameter(GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE); + } + /** + * @param {TurnSignal} signal - See TurnSignal + * @return {GetVehicleDataResponse} + */ + + + setTurnSignal(signal) { + this.validateType(TurnSignal, signal); + this.setParameter(GetVehicleDataResponse.KEY_TURN_SIGNAL, signal); + return this; + } + /** + * @return {TurnSignal} + */ + + + getTurnSignal() { + return this.getObject(TurnSignal, GetVehicleDataResponse.KEY_TURN_SIGNAL); + } + /** + * @param {String} vin - Vehicle identification number + * @return {GetVehicleDataResponse} + */ + + + setVin(vin) { + this.setParameter(GetVehicleDataResponse.KEY_VIN, vin); + return this; + } + /** + * @return {String} + */ + + + getVin() { + return this.getParameter(GetVehicleDataResponse.KEY_VIN); + } + /** + * @param {PRNDL} prndl - See PRNDL + * @return {GetVehicleDataResponse} + */ + + + setPrndl(prndl) { + this.validateType(PRNDL, prndl); + this.setParameter(GetVehicleDataResponse.KEY_PRNDL, prndl); + return this; + } + /** + * @return {PRNDL} + */ + + + getPrndl() { + return this.getObject(PRNDL, GetVehicleDataResponse.KEY_PRNDL); + } + /** + * @param {TireStatus} pressure - See TireStatus + * @return {GetVehicleDataResponse} + */ + + + setTirePressure(pressure) { + this.validateType(TireStatus, pressure); + this.setParameter(GetVehicleDataResponse.KEY_TIRE_PRESSURE, pressure); + return this; + } + /** + * @return {TireStatus} + */ + + + getTirePressure() { + return this.getObject(TireStatus, GetVehicleDataResponse.KEY_TIRE_PRESSURE); + } + /** + * @param {Number} odometer - Odometer in km + * @return {GetVehicleDataResponse} + */ + + + setOdometer(odometer) { + this.setParameter(GetVehicleDataResponse.KEY_ODOMETER, odometer); + return this; + } + /** + * @return {Number} + */ + + + getOdometer() { + return this.getParameter(GetVehicleDataResponse.KEY_ODOMETER); + } + /** + * @param {BeltStatus} status - The status of the seat belts + * @return {GetVehicleDataResponse} + */ + + + setBeltStatus(status) { + this.validateType(BeltStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_BELT_STATUS, status); + return this; + } + /** + * @return {BeltStatus} + */ + + + getBeltStatus() { + return this.getObject(BeltStatus, GetVehicleDataResponse.KEY_BELT_STATUS); + } + /** + * @param {BodyInformation} information - The body information including power modes + * @return {GetVehicleDataResponse} + */ + + + setBodyInformation(information) { + this.validateType(BodyInformation, information); + this.setParameter(GetVehicleDataResponse.KEY_BODY_INFORMATION, information); + return this; + } + /** + * @return {BodyInformation} + */ + + + getBodyInformation() { + return this.getObject(BodyInformation, GetVehicleDataResponse.KEY_BODY_INFORMATION); + } + /** + * @param {DeviceStatus} status - The device status including signal and battery strength + * @return {GetVehicleDataResponse} + */ + + + setDeviceStatus(status) { + this.validateType(DeviceStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_DEVICE_STATUS, status); + return this; + } + /** + * @return {DeviceStatus} + */ + + + getDeviceStatus() { + return this.getObject(DeviceStatus, GetVehicleDataResponse.KEY_DEVICE_STATUS); + } + /** + * @param {VehicleDataEventStatus} braking - The status of the brake pedal + * @return {GetVehicleDataResponse} + */ + + + setDriverBraking(braking) { + this.validateType(VehicleDataEventStatus, braking); + this.setParameter(GetVehicleDataResponse.KEY_DRIVER_BRAKING, braking); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverBraking() { + return this.getObject(VehicleDataEventStatus, GetVehicleDataResponse.KEY_DRIVER_BRAKING); + } + /** + * @param {WiperStatus} status - The status of the wipers + * @return {GetVehicleDataResponse} + */ + + + setWiperStatus(status) { + this.validateType(WiperStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_WIPER_STATUS, status); + return this; + } + /** + * @return {WiperStatus} + */ + + + getWiperStatus() { + return this.getObject(WiperStatus, GetVehicleDataResponse.KEY_WIPER_STATUS); + } + /** + * @param {HeadLampStatus} status - Status of the head lamps + * @return {GetVehicleDataResponse} + */ + + + setHeadLampStatus(status) { + this.validateType(HeadLampStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status); + return this; + } + /** + * @return {HeadLampStatus} + */ + + + getHeadLampStatus() { + return this.getObject(HeadLampStatus, GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS); + } + /** + * @param {Number} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {GetVehicleDataResponse} + */ + + + setEngineTorque(torque) { + this.setParameter(GetVehicleDataResponse.KEY_ENGINE_TORQUE, torque); + return this; + } + /** + * @return {Number} + */ + + + getEngineTorque() { + return this.getParameter(GetVehicleDataResponse.KEY_ENGINE_TORQUE); + } + /** + * @param {Number} position - Accelerator pedal position (percentage depressed) + * @return {GetVehicleDataResponse} + */ + + + setAccPedalPosition(position) { + this.setParameter(GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getAccPedalPosition() { + return this.getParameter(GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION); + } + /** + * @param {Number} angle - Current angle of the steering wheel (in deg) + * @return {GetVehicleDataResponse} + */ + + + setSteeringWheelAngle(angle) { + this.setParameter(GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + /** + * @return {Number} + */ + + + getSteeringWheelAngle() { + return this.getParameter(GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE); + } + /** + * @param {Number} life - The estimated percentage of remaining oil life of the engine. + * @return {GetVehicleDataResponse} + */ + + + setEngineOilLife(life) { + this.setParameter(GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life); + return this; + } + /** + * @return {Number} + */ + + + getEngineOilLife() { + return this.getParameter(GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE); + } + /** + * @param {ElectronicParkBrakeStatus} status - The status of the park brake as provided by Electric Park Brake (EPB) + * system. + * @return {GetVehicleDataResponse} + */ + + + setElectronicParkBrakeStatus(status) { + this.validateType(ElectronicParkBrakeStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + /** + * @return {ElectronicParkBrakeStatus} + */ + + + getElectronicParkBrakeStatus() { + return this.getObject(ElectronicParkBrakeStatus, GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + /** + * @param {String} id - Parameter used by cloud apps to identify a head unit + * @return {GetVehicleDataResponse} + */ + + + setCloudAppVehicleID(id) { + this.setParameter(GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getCloudAppVehicleID() { + return this.getParameter(GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID); + } + /** + * @param {ECallInfo} info - Emergency Call notification and confirmation data + * @return {GetVehicleDataResponse} + */ + + + setECallInfo(info) { + this.validateType(ECallInfo, info); + this.setParameter(GetVehicleDataResponse.KEY_E_CALL_INFO, info); + return this; + } + /** + * @return {ECallInfo} + */ + + + getECallInfo() { + return this.getObject(ECallInfo, GetVehicleDataResponse.KEY_E_CALL_INFO); + } + /** + * @param {AirbagStatus} status - The status of the air bags + * @return {GetVehicleDataResponse} + */ + + + setAirbagStatus(status) { + this.validateType(AirbagStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_AIRBAG_STATUS, status); + return this; + } + /** + * @return {AirbagStatus} + */ + + + getAirbagStatus() { + return this.getObject(AirbagStatus, GetVehicleDataResponse.KEY_AIRBAG_STATUS); + } + /** + * @param {EmergencyEvent} event - Information related to an emergency event (and if it occurred) + * @return {GetVehicleDataResponse} + */ + + + setEmergencyEvent(event) { + this.validateType(EmergencyEvent, event); + this.setParameter(GetVehicleDataResponse.KEY_EMERGENCY_EVENT, event); + return this; + } + /** + * @return {EmergencyEvent} + */ + + + getEmergencyEvent() { + return this.getObject(EmergencyEvent, GetVehicleDataResponse.KEY_EMERGENCY_EVENT); + } + /** + * @param {ClusterModeStatus} status - The status modes of the cluster + * @return {GetVehicleDataResponse} + */ + + + setClusterModeStatus(status) { + this.validateType(ClusterModeStatus, status); + this.setParameter(GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + /** + * @return {ClusterModeStatus} + */ + + + getClusterModeStatus() { + return this.getObject(ClusterModeStatus, GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS); + } + /** + * @param {MyKey} key - Information related to the MyKey feature + * @return {GetVehicleDataResponse} + */ + + + setMyKey(key) { + this.validateType(MyKey, key); + this.setParameter(GetVehicleDataResponse.KEY_MY_KEY, key); + return this; + } + /** + * @return {MyKey} + */ + + + getMyKey() { + return this.getObject(MyKey, GetVehicleDataResponse.KEY_MY_KEY); + } + + } + + GetVehicleDataResponse.KEY_GPS = 'gps'; + GetVehicleDataResponse.KEY_SPEED = 'speed'; + GetVehicleDataResponse.KEY_RPM = 'rpm'; + GetVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel'; + GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; + GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; + GetVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange'; + GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; + GetVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal'; + GetVehicleDataResponse.KEY_VIN = 'vin'; + GetVehicleDataResponse.KEY_PRNDL = 'prndl'; + GetVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure'; + GetVehicleDataResponse.KEY_ODOMETER = 'odometer'; + GetVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus'; + GetVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation'; + GetVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus'; + GetVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking'; + GetVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus'; + GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; + GetVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque'; + GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; + GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; + GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; + GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; + GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; + GetVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo'; + GetVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus'; + GetVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent'; + GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; + GetVehicleDataResponse.KEY_MY_KEY = 'myKey'; + + /* eslint-disable camelcase */ + /** + * Non periodic vehicle data read request + */ + + class ReadDID extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ReadDID); + } + /** + * @param {Number} name - Name of ECU. + * @return {ReadDID} + */ + + + setEcuName(name) { + this.setParameter(ReadDID.KEY_ECU_NAME, name); + return this; + } + /** + * @return {Number} + */ + + + getEcuName() { + return this.getParameter(ReadDID.KEY_ECU_NAME); + } + /** + * @param {Number[]} location - Get raw data from vehicle data DID location(s) + * @return {ReadDID} + */ + + + setDidLocation(location) { + this.setParameter(ReadDID.KEY_DID_LOCATION, location); + return this; + } + /** + * @return {Number[]} + */ + + + getDidLocation() { + return this.getParameter(ReadDID.KEY_DID_LOCATION); + } + + } + + ReadDID.KEY_ECU_NAME = 'ecuName'; + ReadDID.KEY_DID_LOCATION = 'didLocation'; + + /* eslint-disable camelcase */ + /** + * Individual requested DID result and data + */ + + class DIDResult extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {VehicleDataResultCode} code - Individual DID result code. + * @return {DIDResult} + */ + + + setResultCode(code) { + this.validateType(VehicleDataResultCode, code); + this.setParameter(DIDResult.KEY_RESULT_CODE, code); + return this; + } + /** + * @return {VehicleDataResultCode} + */ + + + getResultCode() { + return this.getObject(VehicleDataResultCode, DIDResult.KEY_RESULT_CODE); + } + /** + * @param {Number} location - Location of raw data from vehicle data DID + * @return {DIDResult} + */ + + + setDidLocation(location) { + this.setParameter(DIDResult.KEY_DID_LOCATION, location); + return this; + } + /** + * @return {Number} + */ + + + getDidLocation() { + return this.getParameter(DIDResult.KEY_DID_LOCATION); + } + /** + * @param {String} data - Raw DID-based data returned for requested element. + * @return {DIDResult} + */ + + + setData(data) { + this.setParameter(DIDResult.KEY_DATA, data); + return this; + } + /** + * @return {String} + */ + + + getData() { + return this.getParameter(DIDResult.KEY_DATA); + } + + } + + DIDResult.KEY_RESULT_CODE = 'resultCode'; + DIDResult.KEY_DID_LOCATION = 'didLocation'; + DIDResult.KEY_DATA = 'data'; + + /* eslint-disable camelcase */ + + class ReadDIDResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ReadDID); + } + /** + * @param {DIDResult[]} result - Array of requested DID results (with data if available). + * @return {ReadDIDResponse} + */ + + + setDidResult(result) { + this.validateType(DIDResult, result, true); + this.setParameter(ReadDIDResponse.KEY_DID_RESULT, result); + return this; + } + /** + * @return {DIDResult[]} + */ + + + getDidResult() { + return this.getObject(DIDResult, ReadDIDResponse.KEY_DID_RESULT); + } + + } + + ReadDIDResponse.KEY_DID_RESULT = 'didResult'; + + /* eslint-disable camelcase */ + /** + * Vehicle module diagnostic trouble code request. + */ + + class GetDTCs extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetDTCs); + } + /** + * @param {Number} name - Name of ECU. + * @return {GetDTCs} + */ + + + setEcuName(name) { + this.setParameter(GetDTCs.KEY_ECU_NAME, name); + return this; + } + /** + * @return {Number} + */ + + + getEcuName() { + return this.getParameter(GetDTCs.KEY_ECU_NAME); + } + /** + * @param {Number} mask - DTC Mask Byte to be sent in diagnostic request to module . + * @return {GetDTCs} + */ + + + setDtcMask(mask) { + this.setParameter(GetDTCs.KEY_DTC_MASK, mask); + return this; + } + /** + * @return {Number} + */ + + + getDtcMask() { + return this.getParameter(GetDTCs.KEY_DTC_MASK); + } + + } + + GetDTCs.KEY_ECU_NAME = 'ecuName'; + GetDTCs.KEY_DTC_MASK = 'dtcMask'; + + /* eslint-disable camelcase */ + + class GetDTCsResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetDTCs); + } + /** + * @param {Number} header - 2 byte ECU Header for DTC response (as defined in VHR_Layout_Specification_DTCs.pdf) + * @return {GetDTCsResponse} + */ + + + setEcuHeader(header) { + this.setParameter(GetDTCsResponse.KEY_ECU_HEADER, header); + return this; + } + /** + * @return {Number} + */ + + + getEcuHeader() { + return this.getParameter(GetDTCsResponse.KEY_ECU_HEADER); + } + /** + * @param {String[]} dtc - Array of all reported DTCs on module (ecuHeader contains information if list is + * truncated). Each DTC is represented by 4 bytes (3 bytes of data and 1 byte status as + * defined in VHR_Layout_Specification_DTCs.pdf). + * @return {GetDTCsResponse} + */ + + + setDtc(dtc) { + this.setParameter(GetDTCsResponse.KEY_DTC, dtc); + return this; + } + /** + * @return {String[]} + */ + + + getDtc() { + return this.getParameter(GetDTCsResponse.KEY_DTC); + } + + } + + GetDTCsResponse.KEY_ECU_HEADER = 'ecuHeader'; + GetDTCsResponse.KEY_DTC = 'dtc'; + + /* eslint-disable camelcase */ + /** + * Non periodic vehicle diagnostic request + */ + + class DiagnosticMessage extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DiagnosticMessage); + } + /** + * @param {Number} id - Name of target ECU. + * @return {DiagnosticMessage} + */ + + + setTargetID(id) { + this.setParameter(DiagnosticMessage.KEY_TARGET_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getTargetID() { + return this.getParameter(DiagnosticMessage.KEY_TARGET_ID); + } + /** + * @param {Number} length - Length of message (in bytes). + * @return {DiagnosticMessage} + */ + + + setMessageLength(length) { + this.setParameter(DiagnosticMessage.KEY_MESSAGE_LENGTH, length); + return this; + } + /** + * @return {Number} + */ + + + getMessageLength() { + return this.getParameter(DiagnosticMessage.KEY_MESSAGE_LENGTH); + } + /** + * @param {Number[]} data - Array of bytes comprising CAN message. + * @return {DiagnosticMessage} + */ + + + setMessageData(data) { + this.setParameter(DiagnosticMessage.KEY_MESSAGE_DATA, data); + return this; + } + /** + * @return {Number[]} + */ + + + getMessageData() { + return this.getParameter(DiagnosticMessage.KEY_MESSAGE_DATA); + } + + } + + DiagnosticMessage.KEY_TARGET_ID = 'targetID'; + DiagnosticMessage.KEY_MESSAGE_LENGTH = 'messageLength'; + DiagnosticMessage.KEY_MESSAGE_DATA = 'messageData'; + + /* eslint-disable camelcase */ + + class DiagnosticMessageResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DiagnosticMessage); + } + /** + * @param {Number[]} result - Array of bytes comprising CAN message result. + * @return {DiagnosticMessageResponse} + */ + + + setMessageDataResult(result) { + this.setParameter(DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT, result); + return this; + } + /** + * @return {Number[]} + */ + + + getMessageDataResult() { + return this.getParameter(DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT); + } + + } + + DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT = 'messageDataResult'; + + /* eslint-disable camelcase */ + /** + * Creates a full screen overlay containing a large block of formatted text that can be scrolled with up to 8 + * SoftButtons defined + */ + + class ScrollableMessage extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ScrollableMessage); + } + /** + * @param {String} body - Body of text that can include newlines and tabs. + * @return {ScrollableMessage} + */ + + + setScrollableMessageBody(body) { + this.setParameter(ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY, body); + return this; + } + /** + * @return {String} + */ + + + getScrollableMessageBody() { + return this.getParameter(ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY); + } + /** + * @param {Number} timeout - App defined timeout. Indicates how long of a timeout from the last action (i.e. + * scrolling message resets timeout). + * @return {ScrollableMessage} + */ + + + setTimeout(timeout) { + this.setParameter(ScrollableMessage.KEY_TIMEOUT, timeout); + return this; + } + /** + * @return {Number} + */ + + + getTimeout() { + return this.getParameter(ScrollableMessage.KEY_TIMEOUT); + } + /** + * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, only the system + * defined "Close" SoftButton will be displayed. + * @return {ScrollableMessage} + */ + + + setSoftButtons(buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(ScrollableMessage.KEY_SOFT_BUTTONS, buttons); + return this; + } + /** + * @return {SoftButton[]} + */ + + + getSoftButtons() { + return this.getObject(SoftButton, ScrollableMessage.KEY_SOFT_BUTTONS); + } + /** + * @param {Number} id - An ID for this specific ScrollableMessage to allow cancellation through the + * `CancelInteraction` RPC. + * @return {ScrollableMessage} + */ + + + setCancelID(id) { + this.setParameter(ScrollableMessage.KEY_CANCEL_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCancelID() { + return this.getParameter(ScrollableMessage.KEY_CANCEL_ID); + } + + } + + ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY = 'scrollableMessageBody'; + ScrollableMessage.KEY_TIMEOUT = 'timeout'; + ScrollableMessage.KEY_SOFT_BUTTONS = 'softButtons'; + ScrollableMessage.KEY_CANCEL_ID = 'cancelID'; + + /* eslint-disable camelcase */ + + class ScrollableMessageResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ScrollableMessage); + } + + } + + /* eslint-disable camelcase */ + /** + * Creates a full screen or pop-up overlay (depending on platform) with a single user controlled slider. + */ + + class Slider extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Slider); + } + /** + * @param {Number} ticks - Number of selectable items on a horizontal axis + * @return {Slider} + */ + + + setNumTicks(ticks) { + this.setParameter(Slider.KEY_NUM_TICKS, ticks); + return this; + } + /** + * @return {Number} + */ + + + getNumTicks() { + return this.getParameter(Slider.KEY_NUM_TICKS); + } + /** + * @param {Number} position - Initial position of slider control (cannot exceed numTicks) + * @return {Slider} + */ + + + setPosition(position) { + this.setParameter(Slider.KEY_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getPosition() { + return this.getParameter(Slider.KEY_POSITION); + } + /** + * @param {String} header - Text header to display + * @return {Slider} + */ + + + setSliderHeader(header) { + this.setParameter(Slider.KEY_SLIDER_HEADER, header); + return this; + } + /** + * @return {String} + */ + + + getSliderHeader() { + return this.getParameter(Slider.KEY_SLIDER_HEADER); + } + /** + * @param {String[]} footer - Text footer to display (meant to display min/max threshold descriptors). For a static + * text footer, only one footer string shall be provided in the array. For a dynamic text + * footer, the number of footer text string in the array must match the numTicks value. + * For a dynamic text footer, text array string should correlate with potential slider + * position index. If omitted on supported displays, no footer text shall be displayed. + * @return {Slider} + */ + + + setSliderFooter(footer) { + this.setParameter(Slider.KEY_SLIDER_FOOTER, footer); + return this; + } + /** + * @return {String[]} + */ + + + getSliderFooter() { + return this.getParameter(Slider.KEY_SLIDER_FOOTER); + } + /** + * @param {Number} timeout - App defined timeout. Indicates how long of a timeout from the last action (i.e. sliding + * control resets timeout). If omitted, the value is set to 10000. + * @return {Slider} + */ + + + setTimeout(timeout) { + this.setParameter(Slider.KEY_TIMEOUT, timeout); + return this; + } + /** + * @return {Number} + */ + + + getTimeout() { + return this.getParameter(Slider.KEY_TIMEOUT); + } + /** + * @param {Number} id - An ID for this specific Slider to allow cancellation through the `CancelInteraction` RPC. + * @return {Slider} + */ + + + setCancelID(id) { + this.setParameter(Slider.KEY_CANCEL_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCancelID() { + return this.getParameter(Slider.KEY_CANCEL_ID); + } + + } + + Slider.KEY_NUM_TICKS = 'numTicks'; + Slider.KEY_POSITION = 'position'; + Slider.KEY_SLIDER_HEADER = 'sliderHeader'; + Slider.KEY_SLIDER_FOOTER = 'sliderFooter'; + Slider.KEY_TIMEOUT = 'timeout'; + Slider.KEY_CANCEL_ID = 'cancelID'; + + /* eslint-disable camelcase */ + + class SliderResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.Slider); + } + /** + * @param {Number} position - Current slider value returned when saved or canceled (aborted) This value is only + * returned for resultCodes "SAVED" or "ABORTED" + * @return {SliderResponse} + */ + + + setSliderPosition(position) { + this.setParameter(SliderResponse.KEY_SLIDER_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getSliderPosition() { + return this.getParameter(SliderResponse.KEY_SLIDER_POSITION); + } + + } + + SliderResponse.KEY_SLIDER_POSITION = 'sliderPosition'; + + /* eslint-disable camelcase */ + + class ShowConstantTBT extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ShowConstantTBT); + } + /** + * @param {String} text1 + * @return {ShowConstantTBT} + */ + + + setNavigationText1(text1) { + this.setParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_1, text1); + return this; + } + /** + * @return {String} + */ + + + getNavigationText1() { + return this.getParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_1); + } + /** + * @param {String} text2 + * @return {ShowConstantTBT} + */ + + + setNavigationText2(text2) { + this.setParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_2, text2); + return this; + } + /** + * @return {String} + */ + + + getNavigationText2() { + return this.getParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_2); + } + /** + * @param {String} eta + * @return {ShowConstantTBT} + */ + + + setEta(eta) { + this.setParameter(ShowConstantTBT.KEY_ETA, eta); + return this; + } + /** + * @return {String} + */ + + + getEta() { + return this.getParameter(ShowConstantTBT.KEY_ETA); + } + /** + * @param {String} destination + * @return {ShowConstantTBT} + */ + + + setTimeToDestination(destination) { + this.setParameter(ShowConstantTBT.KEY_TIME_TO_DESTINATION, destination); + return this; + } + /** + * @return {String} + */ + + + getTimeToDestination() { + return this.getParameter(ShowConstantTBT.KEY_TIME_TO_DESTINATION); + } + /** + * @param {String} distance + * @return {ShowConstantTBT} + */ + + + setTotalDistance(distance) { + this.setParameter(ShowConstantTBT.KEY_TOTAL_DISTANCE, distance); + return this; + } + /** + * @return {String} + */ + + + getTotalDistance() { + return this.getParameter(ShowConstantTBT.KEY_TOTAL_DISTANCE); + } + /** + * @param {Image} icon + * @return {ShowConstantTBT} + */ + + + setTurnIcon(icon) { + this.validateType(Image, icon); + this.setParameter(ShowConstantTBT.KEY_TURN_ICON, icon); + return this; + } + /** + * @return {Image} + */ + + + getTurnIcon() { + return this.getObject(Image, ShowConstantTBT.KEY_TURN_ICON); + } + /** + * @param {Image} icon + * @return {ShowConstantTBT} + */ + + + setNextTurnIcon(icon) { + this.validateType(Image, icon); + this.setParameter(ShowConstantTBT.KEY_NEXT_TURN_ICON, icon); + return this; + } + /** + * @return {Image} + */ + + + getNextTurnIcon() { + return this.getObject(Image, ShowConstantTBT.KEY_NEXT_TURN_ICON); + } + /** + * @param {Number} maneuver - Fraction of distance till next maneuver (starting from when AlertManeuver is + * triggered). Used to calculate progress bar. + * @return {ShowConstantTBT} + */ + + + setDistanceToManeuver(maneuver) { + this.setParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER, maneuver); + return this; + } + /** + * @return {Number} + */ + + + getDistanceToManeuver() { + return this.getParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER); + } + /** + * @param {Number} scale - Distance till next maneuver (starting from) from previous maneuver. Used to calculate + * progress bar. + * @return {ShowConstantTBT} + */ + + + setDistanceToManeuverScale(scale) { + this.setParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE, scale); + return this; + } + /** + * @return {Number} + */ + + + getDistanceToManeuverScale() { + return this.getParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE); + } + /** + * @param {Boolean} complete - If and when a maneuver has completed while an AlertManeuver is active, the app must + * send this value set to TRUE in order to clear the AlertManeuver overlay. If omitted + * the value will be assumed as FALSE. + * @return {ShowConstantTBT} + */ + + + setManeuverComplete(complete) { + this.setParameter(ShowConstantTBT.KEY_MANEUVER_COMPLETE, complete); + return this; + } + /** + * @return {Boolean} + */ + + + getManeuverComplete() { + return this.getParameter(ShowConstantTBT.KEY_MANEUVER_COMPLETE); + } + /** + * @param {SoftButton[]} buttons - Three dynamic SoftButtons available (first SoftButton is fixed to "Turns"). If + * omitted on supported displays, the currently displayed SoftButton values will not + * change. + * @return {ShowConstantTBT} + */ + + + setSoftButtons(buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(ShowConstantTBT.KEY_SOFT_BUTTONS, buttons); + return this; + } + /** + * @return {SoftButton[]} + */ + + + getSoftButtons() { + return this.getObject(SoftButton, ShowConstantTBT.KEY_SOFT_BUTTONS); + } + + } + + ShowConstantTBT.KEY_NAVIGATION_TEXT_1 = 'navigationText1'; + ShowConstantTBT.KEY_NAVIGATION_TEXT_2 = 'navigationText2'; + ShowConstantTBT.KEY_ETA = 'eta'; + ShowConstantTBT.KEY_TIME_TO_DESTINATION = 'timeToDestination'; + ShowConstantTBT.KEY_TOTAL_DISTANCE = 'totalDistance'; + ShowConstantTBT.KEY_TURN_ICON = 'turnIcon'; + ShowConstantTBT.KEY_NEXT_TURN_ICON = 'nextTurnIcon'; + ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER = 'distanceToManeuver'; + ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE = 'distanceToManeuverScale'; + ShowConstantTBT.KEY_MANEUVER_COMPLETE = 'maneuverComplete'; + ShowConstantTBT.KEY_SOFT_BUTTONS = 'softButtons'; + + /* eslint-disable camelcase */ + + class ShowConstantTBTResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ShowConstantTBT); + } + + } + + /* eslint-disable camelcase */ + + class AlertManeuver extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.AlertManeuver); + } + /** + * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk + * @return {AlertManeuver} + */ + + + setTtsChunks(chunks) { + this.validateType(TTSChunk, chunks, true); + this.setParameter(AlertManeuver.KEY_TTS_CHUNKS, chunks); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getTtsChunks() { + return this.getObject(TTSChunk, AlertManeuver.KEY_TTS_CHUNKS); + } + /** + * @param {SoftButton[]} buttons - If omitted on supported displays, only the system defined "Close" SoftButton + * shall be displayed. + * @return {AlertManeuver} + */ + + + setSoftButtons(buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(AlertManeuver.KEY_SOFT_BUTTONS, buttons); + return this; + } + /** + * @return {SoftButton[]} + */ + + + getSoftButtons() { + return this.getObject(SoftButton, AlertManeuver.KEY_SOFT_BUTTONS); + } + + } + + AlertManeuver.KEY_TTS_CHUNKS = 'ttsChunks'; + AlertManeuver.KEY_SOFT_BUTTONS = 'softButtons'; + + /* eslint-disable camelcase */ + + class AlertManeuverResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.AlertManeuver); + } + + } + + /* eslint-disable camelcase */ + + class Turn extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} text - Individual turn text. Must provide at least text or icon for a given turn. + * @return {Turn} + */ + + + setNavigationText(text) { + this.setParameter(Turn.KEY_NAVIGATION_TEXT, text); + return this; + } + /** + * @return {String} + */ + + + getNavigationText() { + return this.getParameter(Turn.KEY_NAVIGATION_TEXT); + } + /** + * @param {Image} icon - Individual turn icon. Must provide at least text or icon for a given turn. + * @return {Turn} + */ + + + setTurnIcon(icon) { + this.validateType(Image, icon); + this.setParameter(Turn.KEY_TURN_ICON, icon); + return this; + } + /** + * @return {Image} + */ + + + getTurnIcon() { + return this.getObject(Image, Turn.KEY_TURN_ICON); + } + + } + + Turn.KEY_NAVIGATION_TEXT = 'navigationText'; + Turn.KEY_TURN_ICON = 'turnIcon'; + + /* eslint-disable camelcase */ + + class UpdateTurnList extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UpdateTurnList); + } + /** + * @param {Turn[]} list + * @return {UpdateTurnList} + */ + + + setTurnList(list) { + this.validateType(Turn, list, true); + this.setParameter(UpdateTurnList.KEY_TURN_LIST, list); + return this; + } + /** + * @return {Turn[]} + */ + + + getTurnList() { + return this.getObject(Turn, UpdateTurnList.KEY_TURN_LIST); + } + /** + * @param {SoftButton[]} buttons - If omitted on supported displays, app-defined SoftButton will be left blank. + * @return {UpdateTurnList} + */ + + + setSoftButtons(buttons) { + this.validateType(SoftButton, buttons, true); + this.setParameter(UpdateTurnList.KEY_SOFT_BUTTONS, buttons); + return this; + } + /** + * @return {SoftButton[]} + */ + + + getSoftButtons() { + return this.getObject(SoftButton, UpdateTurnList.KEY_SOFT_BUTTONS); + } + + } + + UpdateTurnList.KEY_TURN_LIST = 'turnList'; + UpdateTurnList.KEY_SOFT_BUTTONS = 'softButtons'; + + /* eslint-disable camelcase */ + + class UpdateTurnListResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UpdateTurnList); + } + + } + + /* eslint-disable camelcase */ + + class ChangeRegistration extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ChangeRegistration); + } + /** + * @param {Language} language - Requested voice engine (VR+TTS) language registration + * @return {ChangeRegistration} + */ + + + setLanguage(language) { + this.validateType(Language, language); + this.setParameter(ChangeRegistration.KEY_LANGUAGE, language); + return this; + } + /** + * @return {Language} + */ + + + getLanguage() { + return this.getObject(Language, ChangeRegistration.KEY_LANGUAGE); + } + /** + * @param {Language} language - Request display language registration + * @return {ChangeRegistration} + */ + + + setHmiDisplayLanguage(language) { + this.validateType(Language, language); + this.setParameter(ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE, language); + return this; + } + /** + * @return {Language} + */ + + + getHmiDisplayLanguage() { + return this.getObject(Language, ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE); + } + /** + * @param {String} name - Request new app name registration + * @return {ChangeRegistration} + */ + + + setAppName(name) { + this.setParameter(ChangeRegistration.KEY_APP_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getAppName() { + return this.getParameter(ChangeRegistration.KEY_APP_NAME); + } + /** + * @param {TTSChunk[]} name - Request new ttsName registration + * @return {ChangeRegistration} + */ + + + setTtsName(name) { + this.validateType(TTSChunk, name, true); + this.setParameter(ChangeRegistration.KEY_TTS_NAME, name); + return this; + } + /** + * @return {TTSChunk[]} + */ + + + getTtsName() { + return this.getObject(TTSChunk, ChangeRegistration.KEY_TTS_NAME); + } + /** + * @param {String} name - Request new app short name registration + * @return {ChangeRegistration} + */ + + + setNgnMediaScreenAppName(name) { + this.setParameter(ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getNgnMediaScreenAppName() { + return this.getParameter(ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME); + } + /** + * @param {String[]} synonyms - Request new VR synonyms registration + * @return {ChangeRegistration} + */ + + + setVrSynonyms(synonyms) { + this.setParameter(ChangeRegistration.KEY_VR_SYNONYMS, synonyms); + return this; + } + /** + * @return {String[]} + */ + + + getVrSynonyms() { + return this.getParameter(ChangeRegistration.KEY_VR_SYNONYMS); + } + + } + + ChangeRegistration.KEY_LANGUAGE = 'language'; + ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; + ChangeRegistration.KEY_APP_NAME = 'appName'; + ChangeRegistration.KEY_TTS_NAME = 'ttsName'; + ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME = 'ngnMediaScreenAppName'; + ChangeRegistration.KEY_VR_SYNONYMS = 'vrSynonyms'; + + /* eslint-disable camelcase */ + + class ChangeRegistrationResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ChangeRegistration); + } + + } + + /* eslint-disable camelcase */ + /** + * Generic Response is sent, when the name of a received msg cannot be retrieved. Only used in case of an error. + * Currently, only resultCode INVALID_DATA is used. + */ + + class GenericResponseResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GenericResponse); + } + + } + + /* eslint-disable camelcase */ + /** + * Used to push a binary data onto the module from a mobile device, such as icons and album art Not supported on first + * generation of SDL enabled modules. Binary data is in binary part of hybrid msg. + */ + + class PutFile extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PutFile); + } // ------ Not part of the RPC spec itself ----- + + /** + * @param {Uint8Array} fileData + * @return {PutFile} + */ + + + setFileData(fileData) { + this.setBulkData(fileData); + return this; + } + /** + * @return {Uint8Array} + */ + + + getFileData() { + return this.getBulkData(); + } // ----------------- END ----------------------- + + /** + * @param {String} name - File reference name. + * @return {PutFile} + */ + + + setFileName(name) { + this.setParameter(PutFile.KEY_FILE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getFileName() { + return this.getParameter(PutFile.KEY_FILE_NAME); + } + /** + * @param {FileType} type - Selected file type. + * @return {PutFile} + */ + + + setFileType(type) { + this.validateType(FileType, type); + this.setParameter(PutFile.KEY_FILE_TYPE, type); + return this; + } + /** + * @return {FileType} + */ + + + getFileType() { + return this.getObject(FileType, PutFile.KEY_FILE_TYPE); + } + /** + * @param {Boolean} file - Indicates if the file is meant to persist between sessions / ignition cycles. If set to + * TRUE, then the system will aim to persist this file through session / cycles. While files + * with this designation will have priority over others, they are subject to deletion by the + * system at any time. In the event of automatic deletion by the system, the app will + * receive a rejection and have to resend the file. If omitted, the value will be set to + * false. + * @return {PutFile} + */ + + + setPersistentFile(file) { + this.setParameter(PutFile.KEY_PERSISTENT_FILE, file); + return this; + } + /** + * @return {Boolean} + */ + + + getPersistentFile() { + return this.getParameter(PutFile.KEY_PERSISTENT_FILE); + } + /** + * @param {Boolean} file - Indicates if the file is meant to be passed thru core to elsewhere on the system. If set + * to TRUE, then the system will instead pass the data thru as it arrives to a predetermined + * area outside of core. If omitted, the value will be set to false. + * @return {PutFile} + */ + + + setSystemFile(file) { + this.setParameter(PutFile.KEY_SYSTEM_FILE, file); + return this; + } + /** + * @return {Boolean} + */ + + + getSystemFile() { + return this.getParameter(PutFile.KEY_SYSTEM_FILE); + } + /** + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {PutFile} + */ + + + setOffset(offset) { + this.setParameter(PutFile.KEY_OFFSET, offset); + return this; + } + /** + * @return {Number} + */ + + + getOffset() { + return this.getParameter(PutFile.KEY_OFFSET); + } + /** + * @param {Number} length - Optional length in bytes for resuming partial data chunks If offset is set to 0, then + * length is the total length of the file to be downloaded + * @return {PutFile} + */ + + + setLength(length) { + this.setParameter(PutFile.KEY_LENGTH, length); + return this; + } + /** + * @return {Number} + */ + + + getLength() { + return this.getParameter(PutFile.KEY_LENGTH); + } + /** + * @param {Number} crc - Additional CRC32 checksum to protect data integrity up to 512 Mbits + * @return {PutFile} + */ + + + setCrc(crc) { + this.setParameter(PutFile.KEY_CRC, crc); + return this; + } + /** + * @return {Number} + */ + + + getCrc() { + return this.getParameter(PutFile.KEY_CRC); + } + + } + + PutFile.KEY_FILE_NAME = 'syncFileName'; + PutFile.KEY_FILE_TYPE = 'fileType'; + PutFile.KEY_PERSISTENT_FILE = 'persistentFile'; + PutFile.KEY_SYSTEM_FILE = 'systemFile'; + PutFile.KEY_OFFSET = 'offset'; + PutFile.KEY_LENGTH = 'length'; + PutFile.KEY_CRC = 'crc'; + + /* eslint-disable camelcase */ + /** + * Response is sent, when the file data was copied (success case). Or when an error occurred. Not supported on first + * generation SDL enabled vehicles. + */ + + class PutFileResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PutFile); + } + /** + * @param {Number} available - Provides the total local space available in SDL Core for the registered app. If the + * transfer has systemFile enabled, then the value will be set to 0 automatically. + * @return {PutFileResponse} + */ + + + setSpaceAvailable(available) { + this.setParameter(PutFileResponse.KEY_SPACE_AVAILABLE, available); + return this; + } + /** + * @return {Number} + */ + + + getSpaceAvailable() { + return this.getParameter(PutFileResponse.KEY_SPACE_AVAILABLE); + } + + } + + PutFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable'; + + /* eslint-disable camelcase */ + /** + * This request is sent to the module to retrieve a file + */ + + class GetFile extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetFile); + } + /** + * @param {String} name - File name that should be retrieved + * @return {GetFile} + */ + + + setFileName(name) { + this.setParameter(GetFile.KEY_FILE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getFileName() { + return this.getParameter(GetFile.KEY_FILE_NAME); + } + /** + * @param {String} id - ID of the service that should have uploaded the requested file. + * @return {GetFile} + */ + + + setAppServiceId(id) { + this.setParameter(GetFile.KEY_APP_SERVICE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getAppServiceId() { + return this.getParameter(GetFile.KEY_APP_SERVICE_ID); + } + /** + * @param {FileType} type - Selected file type. + * @return {GetFile} + */ + + + setFileType(type) { + this.validateType(FileType, type); + this.setParameter(GetFile.KEY_FILE_TYPE, type); + return this; + } + /** + * @return {FileType} + */ + + + getFileType() { + return this.getObject(FileType, GetFile.KEY_FILE_TYPE); + } + /** + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {GetFile} + */ + + + setOffset(offset) { + this.setParameter(GetFile.KEY_OFFSET, offset); + return this; + } + /** + * @return {Number} + */ + + + getOffset() { + return this.getParameter(GetFile.KEY_OFFSET); + } + /** + * @param {Number} length - Optional length in bytes for resuming partial data chunks If offset is set to 0, then + * length is the total length of the file to be retrieved + * @return {GetFile} + */ + + + setLength(length) { + this.setParameter(GetFile.KEY_LENGTH, length); + return this; + } + /** + * @return {Number} + */ + + + getLength() { + return this.getParameter(GetFile.KEY_LENGTH); + } + + } + + GetFile.KEY_FILE_NAME = 'fileName'; + GetFile.KEY_APP_SERVICE_ID = 'appServiceId'; + GetFile.KEY_FILE_TYPE = 'fileType'; + GetFile.KEY_OFFSET = 'offset'; + GetFile.KEY_LENGTH = 'length'; + + /* eslint-disable camelcase */ + /** + * This response includes the data that is requested from the specific service + */ + + class GetFileResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetFile); + } + /** + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {GetFileResponse} + */ + + + setOffset(offset) { + this.setParameter(GetFileResponse.KEY_OFFSET, offset); + return this; + } + /** + * @return {Number} + */ + + + getOffset() { + return this.getParameter(GetFileResponse.KEY_OFFSET); + } + /** + * @param {Number} length - Optional length in bytes for resuming partial data chunks if offset is set to 0, then + * length is the total length of the file to be downloaded + * @return {GetFileResponse} + */ + + + setLength(length) { + this.setParameter(GetFileResponse.KEY_LENGTH, length); + return this; + } + /** + * @return {Number} + */ + + + getLength() { + return this.getParameter(GetFileResponse.KEY_LENGTH); + } + /** + * @param {FileType} type - File type that is being sent in response. + * @return {GetFileResponse} + */ + + + setFileType(type) { + this.validateType(FileType, type); + this.setParameter(GetFileResponse.KEY_FILE_TYPE, type); + return this; + } + /** + * @return {FileType} + */ + + + getFileType() { + return this.getObject(FileType, GetFileResponse.KEY_FILE_TYPE); + } + /** + * @param {Number} crc - Additional CRC32 checksum to protect data integrity up to 512 Mbits + * @return {GetFileResponse} + */ + + + setCrc(crc) { + this.setParameter(GetFileResponse.KEY_CRC, crc); + return this; + } + /** + * @return {Number} + */ + + + getCrc() { + return this.getParameter(GetFileResponse.KEY_CRC); + } + + } + + GetFileResponse.KEY_OFFSET = 'offset'; + GetFileResponse.KEY_LENGTH = 'length'; + GetFileResponse.KEY_FILE_TYPE = 'fileType'; + GetFileResponse.KEY_CRC = 'crc'; + + /* eslint-disable camelcase */ + /** + * Used to delete a file resident on the module in the app's local cache. Not supported on first generation SDL enabled + * vehicles. + */ + + class DeleteFile extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteFile); + } + /** + * @param {String} name - File reference name. + * @return {DeleteFile} + */ + + + setSdlFileName(name) { + this.setParameter(DeleteFile.KEY_SDL_FILE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getSdlFileName() { + return this.getParameter(DeleteFile.KEY_SDL_FILE_NAME); + } + + } + + DeleteFile.KEY_SDL_FILE_NAME = 'syncFileName'; + + /* eslint-disable camelcase */ + /** + * Response is sent, when the file data was deleted (success case). Or when an error occurred. Not supported on First + * generation SDL enabled vehicles. + */ + + class DeleteFileResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DeleteFile); + } + /** + * @param {Number} available - Provides the total local space available on the module for the registered app. + * @return {DeleteFileResponse} + */ + + + setSpaceAvailable(available) { + this.setParameter(DeleteFileResponse.KEY_SPACE_AVAILABLE, available); + return this; + } + /** + * @return {Number} + */ + + + getSpaceAvailable() { + return this.getParameter(DeleteFileResponse.KEY_SPACE_AVAILABLE); + } + + } + + DeleteFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable'; + + /* eslint-disable camelcase */ + /** + * Requests the current list of resident filenames for the registered app. Not supported on first generation SDL + * enabled vehicles. + */ + + class ListFiles extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ListFiles); + } + + } + + /* eslint-disable camelcase */ + /** + * Returns the current list of resident filenames for the registered app along with the current space available Not + * supported on First generation SDL enabled vehicles. + */ + + class ListFilesResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ListFiles); + } + /** + * @param {String[]} filenames - An array of all filenames resident on the module for the given registered app. If + * omitted, then no files currently reside on the system. + * @return {ListFilesResponse} + */ + + + setFilenames(filenames) { + this.setParameter(ListFilesResponse.KEY_FILENAMES, filenames); + return this; + } + /** + * @return {String[]} + */ + + + getFilenames() { + return this.getParameter(ListFilesResponse.KEY_FILENAMES); + } + /** + * @param {Number} available - Provides the total local space available on the module for the registered app. + * @return {ListFilesResponse} + */ + + + setSpaceAvailable(available) { + this.setParameter(ListFilesResponse.KEY_SPACE_AVAILABLE, available); + return this; + } + /** + * @return {Number} + */ + + + getSpaceAvailable() { + return this.getParameter(ListFilesResponse.KEY_SPACE_AVAILABLE); + } + + } + + ListFilesResponse.KEY_FILENAMES = 'filenames'; + ListFilesResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable'; + + /* eslint-disable camelcase */ + /** + * Used to set existing local file on the module as the app's icon Not supported on first generation SDL enabled + * vehicles. + */ + + class SetAppIcon extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetAppIcon); + } + /** + * @param {String} name - File reference name. + * @return {SetAppIcon} + */ + + + setFileName(name) { + this.setParameter(SetAppIcon.KEY_FILE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getFileName() { + return this.getParameter(SetAppIcon.KEY_FILE_NAME); + } + + } + + SetAppIcon.KEY_FILE_NAME = 'syncFileName'; + + /* eslint-disable camelcase */ + /** + * Response is sent, when the file data was copied (success case). Or when an error occurred. Not supported on First + * generation SDL enabled vehicles. + */ + + class SetAppIconResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetAppIcon); + } + + } + + /* eslint-disable camelcase */ + /** + * This RPC is deprecated. Use Show RPC to change layout. + * @deprecated + */ + + class SetDisplayLayout extends RpcRequest { + /** + * @deprecated + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetDisplayLayout); + } + /** + * @deprecated + * @param {String} layout - Predefined or dynamically created screen layout. Currently only predefined screen + * layouts are defined. + * @return {SetDisplayLayout} + */ + + + setDisplayLayout(layout) { + this.setParameter(SetDisplayLayout.KEY_DISPLAY_LAYOUT, layout); + return this; + } + /** + * @deprecated + * @return {String} + */ + + + getDisplayLayout() { + return this.getParameter(SetDisplayLayout.KEY_DISPLAY_LAYOUT); + } + /** + * @deprecated + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {SetDisplayLayout} + */ + + + setDayColorScheme(scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(SetDisplayLayout.KEY_DAY_COLOR_SCHEME, scheme); + return this; + } + /** + * @deprecated + * @return {TemplateColorScheme} + */ + + + getDayColorScheme() { + return this.getObject(TemplateColorScheme, SetDisplayLayout.KEY_DAY_COLOR_SCHEME); + } + /** + * @deprecated + * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates. + * @return {SetDisplayLayout} + */ + + + setNightColorScheme(scheme) { + this.validateType(TemplateColorScheme, scheme); + this.setParameter(SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME, scheme); + return this; + } + /** + * @deprecated + * @return {TemplateColorScheme} + */ + + + getNightColorScheme() { + return this.getObject(TemplateColorScheme, SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME); + } + + } + + SetDisplayLayout.KEY_DISPLAY_LAYOUT = 'displayLayout'; + SetDisplayLayout.KEY_DAY_COLOR_SCHEME = 'dayColorScheme'; + SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme'; + + /* eslint-disable camelcase */ + /** + * This RPC is deprecated. Use Show RPC to change layout. + * @deprecated + */ + + class SetDisplayLayoutResponse extends RpcResponse { + /** + * @deprecated + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetDisplayLayout); + } + /** + * @deprecated + * @param {DisplayCapabilities} capabilities - See DisplayCapabilities + * @return {SetDisplayLayoutResponse} + */ + + + setDisplayCapabilities(capabilities) { + this.validateType(DisplayCapabilities, capabilities); + this.setParameter(SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES, capabilities); + return this; + } + /** + * @deprecated + * @return {DisplayCapabilities} + */ + + + getDisplayCapabilities() { + return this.getObject(DisplayCapabilities, SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES); + } + /** + * @deprecated + * @param {ButtonCapabilities[]} capabilities - See ButtonCapabilities + * @return {SetDisplayLayoutResponse} + */ + + + setButtonCapabilities(capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES, capabilities); + return this; + } + /** + * @deprecated + * @return {ButtonCapabilities[]} + */ + + + getButtonCapabilities() { + return this.getObject(ButtonCapabilities, SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES); + } + /** + * @deprecated + * @param {SoftButtonCapabilities[]} capabilities - If returned, the platform supports on-screen SoftButtons; see + * SoftButtonCapabilities. + * @return {SetDisplayLayoutResponse} + */ + + + setSoftButtonCapabilities(capabilities) { + this.validateType(SoftButtonCapabilities, capabilities, true); + this.setParameter(SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES, capabilities); + return this; + } + /** + * @deprecated + * @return {SoftButtonCapabilities[]} + */ + + + getSoftButtonCapabilities() { + return this.getObject(SoftButtonCapabilities, SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES); + } + /** + * @deprecated + * @param {PresetBankCapabilities} capabilities - If returned, the platform supports custom on-screen Presets; see + * PresetBankCapabilities. + * @return {SetDisplayLayoutResponse} + */ + + + setPresetBankCapabilities(capabilities) { + this.validateType(PresetBankCapabilities, capabilities); + this.setParameter(SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES, capabilities); + return this; + } + /** + * @deprecated + * @return {PresetBankCapabilities} + */ + + + getPresetBankCapabilities() { + return this.getObject(PresetBankCapabilities, SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES); + } + + } + + SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities'; + SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; + SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities'; + SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES = 'presetBankCapabilities'; + + /* eslint-disable camelcase */ + /** + * Enumeration listing possible asynchronous requests. + * @typedef {Enum} RequestType + * @property {Object} _MAP + */ + + class RequestType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get HTTP() { + return RequestType._MAP.HTTP; + } + /** + * @return {String} + */ + + + static get FILE_RESUME() { + return RequestType._MAP.FILE_RESUME; + } + /** + * @return {String} + */ + + + static get AUTH_REQUEST() { + return RequestType._MAP.AUTH_REQUEST; + } + /** + * @return {String} + */ + + + static get AUTH_CHALLENGE() { + return RequestType._MAP.AUTH_CHALLENGE; + } + /** + * @return {String} + */ + + + static get AUTH_ACK() { + return RequestType._MAP.AUTH_ACK; + } + /** + * @return {String} + */ + + + static get PROPRIETARY() { + return RequestType._MAP.PROPRIETARY; + } + /** + * @return {String} + */ + + + static get QUERY_APPS() { + return RequestType._MAP.QUERY_APPS; + } + /** + * @return {String} + */ + + + static get LAUNCH_APP() { + return RequestType._MAP.LAUNCH_APP; + } + /** + * @return {String} + */ + + + static get LOCK_SCREEN_ICON_URL() { + return RequestType._MAP.LOCK_SCREEN_ICON_URL; + } + /** + * @return {String} + */ + + + static get TRAFFIC_MESSAGE_CHANNEL() { + return RequestType._MAP.TRAFFIC_MESSAGE_CHANNEL; + } + /** + * @return {String} + */ + + + static get DRIVER_PROFILE() { + return RequestType._MAP.DRIVER_PROFILE; + } + /** + * @return {String} + */ + + + static get VOICE_SEARCH() { + return RequestType._MAP.VOICE_SEARCH; + } + /** + * @return {String} + */ + + + static get NAVIGATION() { + return RequestType._MAP.NAVIGATION; + } + /** + * @return {String} + */ + + + static get PHONE() { + return RequestType._MAP.PHONE; + } + /** + * @return {String} + */ + + + static get CLIMATE() { + return RequestType._MAP.CLIMATE; + } + /** + * @return {String} + */ + + + static get SETTINGS() { + return RequestType._MAP.SETTINGS; + } + /** + * @return {String} + */ + + + static get VEHICLE_DIAGNOSTICS() { + return RequestType._MAP.VEHICLE_DIAGNOSTICS; + } + /** + * @return {String} + */ + + + static get EMERGENCY() { + return RequestType._MAP.EMERGENCY; + } + /** + * @return {String} + */ + + + static get MEDIA() { + return RequestType._MAP.MEDIA; + } + /** + * @return {String} + */ + + + static get FOTA() { + return RequestType._MAP.FOTA; + } + /** + * @return {String} + */ + + + static get OEM_SPECIFIC() { + return RequestType._MAP.OEM_SPECIFIC; + } + /** + * @return {String} + */ + + + static get ICON_URL() { + return RequestType._MAP.ICON_URL; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return RequestType._valueForKey(key, RequestType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return RequestType._keyForValue(value, RequestType._MAP); + } + + } + + RequestType._MAP = Object.freeze({ + 'HTTP': 'HTTP', + 'FILE_RESUME': 'FILE_RESUME', + 'AUTH_REQUEST': 'AUTH_REQUEST', + 'AUTH_CHALLENGE': 'AUTH_CHALLENGE', + 'AUTH_ACK': 'AUTH_ACK', + 'PROPRIETARY': 'PROPRIETARY', + 'QUERY_APPS': 'QUERY_APPS', + 'LAUNCH_APP': 'LAUNCH_APP', + 'LOCK_SCREEN_ICON_URL': 'LOCK_SCREEN_ICON_URL', + 'TRAFFIC_MESSAGE_CHANNEL': 'TRAFFIC_MESSAGE_CHANNEL', + 'DRIVER_PROFILE': 'DRIVER_PROFILE', + 'VOICE_SEARCH': 'VOICE_SEARCH', + 'NAVIGATION': 'NAVIGATION', + 'PHONE': 'PHONE', + 'CLIMATE': 'CLIMATE', + 'SETTINGS': 'SETTINGS', + 'VEHICLE_DIAGNOSTICS': 'VEHICLE_DIAGNOSTICS', + 'EMERGENCY': 'EMERGENCY', + 'MEDIA': 'MEDIA', + 'FOTA': 'FOTA', + 'OEM_SPECIFIC': 'OEM_SPECIFIC', + 'ICON_URL': 'ICON_URL' + }); + + /* eslint-disable camelcase */ + /** + * An asynchronous request from the device; binary data can be included in hybrid part of message for some requests + * (such as HTTP, Proprietary, or Authentication requests) + */ + + class SystemRequest extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SystemRequest); + } + /** + * @param {RequestType} type - The type of system request. Note that Proprietary requests should forward the binary + * data to the known proprietary module on the system. + * @return {SystemRequest} + */ + + + setRequestType(type) { + this.validateType(RequestType, type); + this.setParameter(SystemRequest.KEY_REQUEST_TYPE, type); + return this; + } + /** + * @return {RequestType} + */ + + + getRequestType() { + return this.getObject(RequestType, SystemRequest.KEY_REQUEST_TYPE); + } + /** + * @param {String} type - This parameter is filled for supporting OEM proprietary data exchanges. + * @return {SystemRequest} + */ + + + setRequestSubType(type) { + this.setParameter(SystemRequest.KEY_REQUEST_SUB_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getRequestSubType() { + return this.getParameter(SystemRequest.KEY_REQUEST_SUB_TYPE); + } + /** + * @param {String} name - Filename of HTTP data to store in predefined system staging area. Mandatory if requestType + * is HTTP. PROPRIETARY requestType should ignore this parameter. + * @return {SystemRequest} + */ + + + setFileName(name) { + this.setParameter(SystemRequest.KEY_FILE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getFileName() { + return this.getParameter(SystemRequest.KEY_FILE_NAME); + } + + } + + SystemRequest.KEY_REQUEST_TYPE = 'requestType'; + SystemRequest.KEY_REQUEST_SUB_TYPE = 'requestSubType'; + SystemRequest.KEY_FILE_NAME = 'fileName'; + + /* eslint-disable camelcase */ + + class SystemRequestResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SystemRequest); + } + + } + + /* eslint-disable camelcase */ + /** + * The mode in which the SendLocation request is sent + * @typedef {Enum} DeliveryMode + * @property {Object} _MAP + */ + + class DeliveryMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get PROMPT() { + return DeliveryMode._MAP.PROMPT; + } + /** + * @return {String} + */ + + + static get DESTINATION() { + return DeliveryMode._MAP.DESTINATION; + } + /** + * @return {String} + */ + + + static get QUEUE() { + return DeliveryMode._MAP.QUEUE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return DeliveryMode._valueForKey(key, DeliveryMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return DeliveryMode._keyForValue(value, DeliveryMode._MAP); + } + + } + + DeliveryMode._MAP = Object.freeze({ + 'PROMPT': 'PROMPT', + 'DESTINATION': 'DESTINATION', + 'QUEUE': 'QUEUE' + }); + + /* eslint-disable camelcase */ + + class DateTime extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} millisecond - Milliseconds + * @return {DateTime} + */ + + + setMillisecond(millisecond) { + this.setParameter(DateTime.KEY_MILLISECOND, millisecond); + return this; + } + /** + * @return {Number} + */ + + + getMillisecond() { + return this.getParameter(DateTime.KEY_MILLISECOND); + } + /** + * @param {Number} second - Seconds part of time + * @return {DateTime} + */ + + + setSecond(second) { + this.setParameter(DateTime.KEY_SECOND, second); + return this; + } + /** + * @return {Number} + */ + + + getSecond() { + return this.getParameter(DateTime.KEY_SECOND); + } + /** + * @param {Number} minute - Minutes part of time + * @return {DateTime} + */ + + + setMinute(minute) { + this.setParameter(DateTime.KEY_MINUTE, minute); + return this; + } + /** + * @return {Number} + */ + + + getMinute() { + return this.getParameter(DateTime.KEY_MINUTE); + } + /** + * @param {Number} hour - Hours part of time. Note that this structure accepts time only in 24 Hr format + * @return {DateTime} + */ + + + setHour(hour) { + this.setParameter(DateTime.KEY_HOUR, hour); + return this; + } + /** + * @return {Number} + */ + + + getHour() { + return this.getParameter(DateTime.KEY_HOUR); + } + /** + * @param {Number} day - Day of the month + * @return {DateTime} + */ + + + setDay(day) { + this.setParameter(DateTime.KEY_DAY, day); + return this; + } + /** + * @return {Number} + */ + + + getDay() { + return this.getParameter(DateTime.KEY_DAY); + } + /** + * @param {Number} month - Month of the year + * @return {DateTime} + */ + + + setMonth(month) { + this.setParameter(DateTime.KEY_MONTH, month); + return this; + } + /** + * @return {Number} + */ + + + getMonth() { + return this.getParameter(DateTime.KEY_MONTH); + } + /** + * @param {Number} year - The year in YYYY format + * @return {DateTime} + */ + + + setYear(year) { + this.setParameter(DateTime.KEY_YEAR, year); + return this; + } + /** + * @return {Number} + */ + + + getYear() { + return this.getParameter(DateTime.KEY_YEAR); + } + /** + * @param {Number} tz_hour - Time zone offset in Hours wrt UTC. + * @return {DateTime} + */ + + + setTz_hour(tz_hour) { + this.setParameter(DateTime.KEY_TZ_HOUR, tz_hour); + return this; + } + /** + * @return {Number} + */ + + + getTz_hour() { + return this.getParameter(DateTime.KEY_TZ_HOUR); + } + /** + * @param {Number} tz_minute - Time zone offset in Min wrt UTC. + * @return {DateTime} + */ + + + setTz_minute(tz_minute) { + this.setParameter(DateTime.KEY_TZ_MINUTE, tz_minute); + return this; + } + /** + * @return {Number} + */ + + + getTz_minute() { + return this.getParameter(DateTime.KEY_TZ_MINUTE); + } + + } + + DateTime.KEY_MILLISECOND = 'millisecond'; + DateTime.KEY_SECOND = 'second'; + DateTime.KEY_MINUTE = 'minute'; + DateTime.KEY_HOUR = 'hour'; + DateTime.KEY_DAY = 'day'; + DateTime.KEY_MONTH = 'month'; + DateTime.KEY_YEAR = 'year'; + DateTime.KEY_TZ_HOUR = 'tz_hour'; + DateTime.KEY_TZ_MINUTE = 'tz_minute'; + + /* eslint-disable camelcase */ + + class OASISAddress extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - Name of the country (localized) + * @return {OASISAddress} + */ + + + setCountryName(name) { + this.setParameter(OASISAddress.KEY_COUNTRY_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getCountryName() { + return this.getParameter(OASISAddress.KEY_COUNTRY_NAME); + } + /** + * @param {String} code - Name of country (ISO 3166-2) + * @return {OASISAddress} + */ + + + setCountryCode(code) { + this.setParameter(OASISAddress.KEY_COUNTRY_CODE, code); + return this; + } + /** + * @return {String} + */ + + + getCountryCode() { + return this.getParameter(OASISAddress.KEY_COUNTRY_CODE); + } + /** + * @param {String} code - (PLZ, ZIP, PIN, CAP etc.) + * @return {OASISAddress} + */ + + + setPostalCode(code) { + this.setParameter(OASISAddress.KEY_POSTAL_CODE, code); + return this; + } + /** + * @return {String} + */ + + + getPostalCode() { + return this.getParameter(OASISAddress.KEY_POSTAL_CODE); + } + /** + * @param {String} area - Portion of country (e.g. state) + * @return {OASISAddress} + */ + + + setAdministrativeArea(area) { + this.setParameter(OASISAddress.KEY_ADMINISTRATIVE_AREA, area); + return this; + } + /** + * @return {String} + */ + + + getAdministrativeArea() { + return this.getParameter(OASISAddress.KEY_ADMINISTRATIVE_AREA); + } + /** + * @param {String} area - Portion of e.g. state (e.g. county) + * @return {OASISAddress} + */ + + + setSubAdministrativeArea(area) { + this.setParameter(OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA, area); + return this; + } + /** + * @return {String} + */ + + + getSubAdministrativeArea() { + return this.getParameter(OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA); + } + /** + * @param {String} locality - Hypernym for e.g. city/village + * @return {OASISAddress} + */ + + + setLocality(locality) { + this.setParameter(OASISAddress.KEY_LOCALITY, locality); + return this; + } + /** + * @return {String} + */ + + + getLocality() { + return this.getParameter(OASISAddress.KEY_LOCALITY); + } + /** + * @param {String} locality - Hypernym for e.g. district + * @return {OASISAddress} + */ + + + setSubLocality(locality) { + this.setParameter(OASISAddress.KEY_SUB_LOCALITY, locality); + return this; + } + /** + * @return {String} + */ + + + getSubLocality() { + return this.getParameter(OASISAddress.KEY_SUB_LOCALITY); + } + /** + * @param {String} thoroughfare - Hypernym for street, road etc. + * @return {OASISAddress} + */ + + + setThoroughfare(thoroughfare) { + this.setParameter(OASISAddress.KEY_THOROUGHFARE, thoroughfare); + return this; + } + /** + * @return {String} + */ + + + getThoroughfare() { + return this.getParameter(OASISAddress.KEY_THOROUGHFARE); + } + /** + * @param {String} thoroughfare - Portion of thoroughfare e.g. house number + * @return {OASISAddress} + */ + + + setSubThoroughfare(thoroughfare) { + this.setParameter(OASISAddress.KEY_SUB_THOROUGHFARE, thoroughfare); + return this; + } + /** + * @return {String} + */ + + + getSubThoroughfare() { + return this.getParameter(OASISAddress.KEY_SUB_THOROUGHFARE); + } + + } + + OASISAddress.KEY_COUNTRY_NAME = 'countryName'; + OASISAddress.KEY_COUNTRY_CODE = 'countryCode'; + OASISAddress.KEY_POSTAL_CODE = 'postalCode'; + OASISAddress.KEY_ADMINISTRATIVE_AREA = 'administrativeArea'; + OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA = 'subAdministrativeArea'; + OASISAddress.KEY_LOCALITY = 'locality'; + OASISAddress.KEY_SUB_LOCALITY = 'subLocality'; + OASISAddress.KEY_THOROUGHFARE = 'thoroughfare'; + OASISAddress.KEY_SUB_THOROUGHFARE = 'subThoroughfare'; + + /* eslint-disable camelcase */ + + class SendLocation extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SendLocation); + } + /** + * @param {Number} degrees + * @return {SendLocation} + */ + + + setLongitudeDegrees(degrees) { + this.setParameter(SendLocation.KEY_LONGITUDE_DEGREES, degrees); + return this; + } + /** + * @return {Number} + */ + + + getLongitudeDegrees() { + return this.getParameter(SendLocation.KEY_LONGITUDE_DEGREES); + } + /** + * @param {Number} degrees + * @return {SendLocation} + */ + + + setLatitudeDegrees(degrees) { + this.setParameter(SendLocation.KEY_LATITUDE_DEGREES, degrees); + return this; + } + /** + * @return {Number} + */ + + + getLatitudeDegrees() { + return this.getParameter(SendLocation.KEY_LATITUDE_DEGREES); + } + /** + * @param {String} name - Name / title of intended location + * @return {SendLocation} + */ + + + setLocationName(name) { + this.setParameter(SendLocation.KEY_LOCATION_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getLocationName() { + return this.getParameter(SendLocation.KEY_LOCATION_NAME); + } + /** + * @param {String} description - Description intended location / establishment (if applicable) + * @return {SendLocation} + */ + + + setLocationDescription(description) { + this.setParameter(SendLocation.KEY_LOCATION_DESCRIPTION, description); + return this; + } + /** + * @return {String} + */ + + + getLocationDescription() { + return this.getParameter(SendLocation.KEY_LOCATION_DESCRIPTION); + } + /** + * @param {String[]} lines - Location address (if applicable) + * @return {SendLocation} + */ + + + setAddressLines(lines) { + this.setParameter(SendLocation.KEY_ADDRESS_LINES, lines); + return this; + } + /** + * @return {String[]} + */ + + + getAddressLines() { + return this.getParameter(SendLocation.KEY_ADDRESS_LINES); + } + /** + * @param {String} number - Phone number of intended location / establishment (if applicable) + * @return {SendLocation} + */ + + + setPhoneNumber(number) { + this.setParameter(SendLocation.KEY_PHONE_NUMBER, number); + return this; + } + /** + * @return {String} + */ + + + getPhoneNumber() { + return this.getParameter(SendLocation.KEY_PHONE_NUMBER); + } + /** + * @param {Image} image - Image / icon of intended location (if applicable and supported) + * @return {SendLocation} + */ + + + setLocationImage(image) { + this.validateType(Image, image); + this.setParameter(SendLocation.KEY_LOCATION_IMAGE, image); + return this; + } + /** + * @return {Image} + */ + + + getLocationImage() { + return this.getObject(Image, SendLocation.KEY_LOCATION_IMAGE); + } + /** + * @param {DateTime} stamp - timestamp in ISO 8601 format + * @return {SendLocation} + */ + + + setTimeStamp(stamp) { + this.validateType(DateTime, stamp); + this.setParameter(SendLocation.KEY_TIME_STAMP, stamp); + return this; + } + /** + * @return {DateTime} + */ + + + getTimeStamp() { + return this.getObject(DateTime, SendLocation.KEY_TIME_STAMP); + } + /** + * @param {OASISAddress} address - Address to be used for setting destination + * @return {SendLocation} + */ + + + setAddress(address) { + this.validateType(OASISAddress, address); + this.setParameter(SendLocation.KEY_ADDRESS, address); + return this; + } + /** + * @return {OASISAddress} + */ + + + getAddress() { + return this.getObject(OASISAddress, SendLocation.KEY_ADDRESS); + } + /** + * @param {DeliveryMode} mode - Defines the mode of prompt for user + * @return {SendLocation} + */ + + + setDeliveryMode(mode) { + this.validateType(DeliveryMode, mode); + this.setParameter(SendLocation.KEY_DELIVERY_MODE, mode); + return this; + } + /** + * @return {DeliveryMode} + */ + + + getDeliveryMode() { + return this.getObject(DeliveryMode, SendLocation.KEY_DELIVERY_MODE); + } + + } + + SendLocation.KEY_LONGITUDE_DEGREES = 'longitudeDegrees'; + SendLocation.KEY_LATITUDE_DEGREES = 'latitudeDegrees'; + SendLocation.KEY_LOCATION_NAME = 'locationName'; + SendLocation.KEY_LOCATION_DESCRIPTION = 'locationDescription'; + SendLocation.KEY_ADDRESS_LINES = 'addressLines'; + SendLocation.KEY_PHONE_NUMBER = 'phoneNumber'; + SendLocation.KEY_LOCATION_IMAGE = 'locationImage'; + SendLocation.KEY_TIME_STAMP = 'timeStamp'; + SendLocation.KEY_ADDRESS = 'address'; + SendLocation.KEY_DELIVERY_MODE = 'deliveryMode'; + + /* eslint-disable camelcase */ + + class SendLocationResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SendLocation); + } + + } + + /* eslint-disable camelcase */ + /** + * Dials a phone number and switches to phone application. + */ + + class DialNumber extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DialNumber); + } + /** + * @param {String} number - Phone number is a string, which can be up to 40 chars. All characters shall be stripped + * from string except digits 0-9 and * # , ; + + * @return {DialNumber} + */ + + + setNumber(number) { + this.setParameter(DialNumber.KEY_NUMBER, number); + return this; + } + /** + * @return {String} + */ + + + getNumber() { + return this.getParameter(DialNumber.KEY_NUMBER); + } + + } + + DialNumber.KEY_NUMBER = 'number'; + + /* eslint-disable camelcase */ + + class DialNumberResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.DialNumber); + } + + } + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} ButtonPressMode + * @property {Object} _MAP + */ + + class ButtonPressMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * A button was released, after it was pressed for a long time Actual timing is defined by the headunit and may + * vary + * @return {String} + */ + + + static get LONG() { + return ButtonPressMode._MAP.LONG; + } + /** + * A button was released, after it was pressed for a short time Actual timing is defined by the headunit and may + * vary + * @return {String} + */ + + + static get SHORT() { + return ButtonPressMode._MAP.SHORT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ButtonPressMode._valueForKey(key, ButtonPressMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ButtonPressMode._keyForValue(value, ButtonPressMode._MAP); + } + + } + + ButtonPressMode._MAP = Object.freeze({ + 'LONG': 'LONG', + 'SHORT': 'SHORT' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} ModuleType + * @property {Object} _MAP + */ + + class ModuleType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get CLIMATE() { + return ModuleType._MAP.CLIMATE; + } + /** + * @return {String} + */ + + + static get RADIO() { + return ModuleType._MAP.RADIO; + } + /** + * @return {String} + */ + + + static get SEAT() { + return ModuleType._MAP.SEAT; + } + /** + * @return {String} + */ + + + static get AUDIO() { + return ModuleType._MAP.AUDIO; + } + /** + * @return {String} + */ + + + static get LIGHT() { + return ModuleType._MAP.LIGHT; + } + /** + * @return {String} + */ + + + static get HMI_SETTINGS() { + return ModuleType._MAP.HMI_SETTINGS; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ModuleType._valueForKey(key, ModuleType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ModuleType._keyForValue(value, ModuleType._MAP); + } + + } + + ModuleType._MAP = Object.freeze({ + 'CLIMATE': 'CLIMATE', + 'RADIO': 'RADIO', + 'SEAT': 'SEAT', + 'AUDIO': 'AUDIO', + 'LIGHT': 'LIGHT', + 'HMI_SETTINGS': 'HMI_SETTINGS' + }); + + /* eslint-disable camelcase */ + + class ButtonPress extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ButtonPress); + } + /** + * @param {ModuleType} type - The module where the button should be pressed + * @return {ButtonPress} + */ + + + setModuleType(type) { + this.validateType(ModuleType, type); + this.setParameter(ButtonPress.KEY_MODULE_TYPE, type); + return this; + } + /** + * @return {ModuleType} + */ + + + getModuleType() { + return this.getObject(ModuleType, ButtonPress.KEY_MODULE_TYPE); + } + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {ButtonPress} + */ + + + setModuleId(id) { + this.setParameter(ButtonPress.KEY_MODULE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getModuleId() { + return this.getParameter(ButtonPress.KEY_MODULE_ID); + } + /** + * @param {ButtonName} name - The name of supported RC climate or radio button. + * @return {ButtonPress} + */ + + + setButtonName(name) { + this.validateType(ButtonName, name); + this.setParameter(ButtonPress.KEY_BUTTON_NAME, name); + return this; + } + /** + * @return {ButtonName} + */ + + + getButtonName() { + return this.getObject(ButtonName, ButtonPress.KEY_BUTTON_NAME); + } + /** + * @param {ButtonPressMode} mode - Indicates whether this is a LONG or SHORT button press event. + * @return {ButtonPress} + */ + + + setButtonPressMode(mode) { + this.validateType(ButtonPressMode, mode); + this.setParameter(ButtonPress.KEY_BUTTON_PRESS_MODE, mode); + return this; + } + /** + * @return {ButtonPressMode} + */ + + + getButtonPressMode() { + return this.getObject(ButtonPressMode, ButtonPress.KEY_BUTTON_PRESS_MODE); + } + + } + + ButtonPress.KEY_MODULE_TYPE = 'moduleType'; + ButtonPress.KEY_MODULE_ID = 'moduleId'; + ButtonPress.KEY_BUTTON_NAME = 'buttonName'; + ButtonPress.KEY_BUTTON_PRESS_MODE = 'buttonPressMode'; + + /* eslint-disable camelcase */ + + class ButtonPressResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ButtonPress); + } + + } + + /* eslint-disable camelcase */ + + class GetInteriorVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleData); + } + /** + * @param {ModuleType} type - The type of a RC module to retrieve module data from the vehicle. In the future, this + * should be the Identification of a module. + * @return {GetInteriorVehicleData} + */ + + + setModuleType(type) { + this.validateType(ModuleType, type); + this.setParameter(GetInteriorVehicleData.KEY_MODULE_TYPE, type); + return this; + } + /** + * @return {ModuleType} + */ + + + getModuleType() { + return this.getObject(ModuleType, GetInteriorVehicleData.KEY_MODULE_TYPE); + } + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {GetInteriorVehicleData} + */ + + + setModuleId(id) { + this.setParameter(GetInteriorVehicleData.KEY_MODULE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getModuleId() { + return this.getParameter(GetInteriorVehicleData.KEY_MODULE_ID); + } + /** + * @param {Boolean} subscribe - If subscribe is true, the head unit will register OnInteriorVehicleData + * notifications for the requested module (moduleId and moduleType). If subscribe is + * false, the head unit will unregister OnInteriorVehicleData notifications for the + * requested module (moduleId and moduleType). If subscribe is not included, the + * subscription status of the app for the requested module (moduleId and moduleType) + * will remain unchanged. + * @return {GetInteriorVehicleData} + */ + + + setSubscribe(subscribe) { + this.setParameter(GetInteriorVehicleData.KEY_SUBSCRIBE, subscribe); + return this; + } + /** + * @return {Boolean} + */ + + + getSubscribe() { + return this.getParameter(GetInteriorVehicleData.KEY_SUBSCRIBE); + } + + } + + GetInteriorVehicleData.KEY_MODULE_TYPE = 'moduleType'; + GetInteriorVehicleData.KEY_MODULE_ID = 'moduleId'; + GetInteriorVehicleData.KEY_SUBSCRIBE = 'subscribe'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} DisplayMode + * @property {Object} _MAP + */ + + class DisplayMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get DAY() { + return DisplayMode._MAP.DAY; + } + /** + * @return {String} + */ + + + static get NIGHT() { + return DisplayMode._MAP.NIGHT; + } + /** + * @return {String} + */ + + + static get AUTO() { + return DisplayMode._MAP.AUTO; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return DisplayMode._valueForKey(key, DisplayMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return DisplayMode._keyForValue(value, DisplayMode._MAP); + } + + } + + DisplayMode._MAP = Object.freeze({ + 'DAY': 'DAY', + 'NIGHT': 'NIGHT', + 'AUTO': 'AUTO' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} DistanceUnit + * @property {Object} _MAP + */ + + class DistanceUnit extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get MILES() { + return DistanceUnit._MAP.MILES; + } + /** + * @return {String} + */ + + + static get KILOMETERS() { + return DistanceUnit._MAP.KILOMETERS; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return DistanceUnit._valueForKey(key, DistanceUnit._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return DistanceUnit._keyForValue(value, DistanceUnit._MAP); + } + + } + + DistanceUnit._MAP = Object.freeze({ + 'MILES': 'MILES', + 'KILOMETERS': 'KILOMETERS' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} TemperatureUnit + * @property {Object} _MAP + */ + + class TemperatureUnit extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get FAHRENHEIT() { + return TemperatureUnit._MAP.FAHRENHEIT; + } + /** + * @return {String} + */ + + + static get CELSIUS() { + return TemperatureUnit._MAP.CELSIUS; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return TemperatureUnit._valueForKey(key, TemperatureUnit._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return TemperatureUnit._keyForValue(value, TemperatureUnit._MAP); + } + + } + + TemperatureUnit._MAP = Object.freeze({ + 'FAHRENHEIT': 'FAHRENHEIT', + 'CELSIUS': 'CELSIUS' + }); + + /* eslint-disable camelcase */ + /** + * Corresponds to "HMI_SETTINGS" ModuleType + */ + + class HMISettingsControlData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {DisplayMode} mode + * @return {HMISettingsControlData} + */ + + + setDisplayMode(mode) { + this.validateType(DisplayMode, mode); + this.setParameter(HMISettingsControlData.KEY_DISPLAY_MODE, mode); + return this; + } + /** + * @return {DisplayMode} + */ + + + getDisplayMode() { + return this.getObject(DisplayMode, HMISettingsControlData.KEY_DISPLAY_MODE); + } + /** + * @param {TemperatureUnit} unit + * @return {HMISettingsControlData} + */ + + + setTemperatureUnit(unit) { + this.validateType(TemperatureUnit, unit); + this.setParameter(HMISettingsControlData.KEY_TEMPERATURE_UNIT, unit); + return this; + } + /** + * @return {TemperatureUnit} + */ + + + getTemperatureUnit() { + return this.getObject(TemperatureUnit, HMISettingsControlData.KEY_TEMPERATURE_UNIT); + } + /** + * @param {DistanceUnit} unit + * @return {HMISettingsControlData} + */ + + + setDistanceUnit(unit) { + this.validateType(DistanceUnit, unit); + this.setParameter(HMISettingsControlData.KEY_DISTANCE_UNIT, unit); + return this; + } + /** + * @return {DistanceUnit} + */ + + + getDistanceUnit() { + return this.getObject(DistanceUnit, HMISettingsControlData.KEY_DISTANCE_UNIT); + } + + } + + HMISettingsControlData.KEY_DISPLAY_MODE = 'displayMode'; + HMISettingsControlData.KEY_TEMPERATURE_UNIT = 'temperatureUnit'; + HMISettingsControlData.KEY_DISTANCE_UNIT = 'distanceUnit'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} RadioBand + * @property {Object} _MAP + */ + + class RadioBand extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get AM() { + return RadioBand._MAP.AM; + } + /** + * @return {String} + */ + + + static get FM() { + return RadioBand._MAP.FM; + } + /** + * @return {String} + */ + + + static get XM() { + return RadioBand._MAP.XM; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return RadioBand._valueForKey(key, RadioBand._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return RadioBand._keyForValue(value, RadioBand._MAP); + } + + } + + RadioBand._MAP = Object.freeze({ + 'AM': 'AM', + 'FM': 'FM', + 'XM': 'XM' + }); + + /* eslint-disable camelcase */ + + class RdsData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} ps - Program Service Name + * @return {RdsData} + */ + + + setPS(ps) { + this.setParameter(RdsData.KEY_PS, ps); + return this; + } + /** + * @return {String} + */ + + + getPS() { + return this.getParameter(RdsData.KEY_PS); + } + /** + * @param {String} rt - Radio Text + * @return {RdsData} + */ + + + setRT(rt) { + this.setParameter(RdsData.KEY_RT, rt); + return this; + } + /** + * @return {String} + */ + + + getRT() { + return this.getParameter(RdsData.KEY_RT); + } + /** + * @param {String} ct - The clock text in UTC format as YYYY-MM-DDThh:mm:ss.sTZD + * @return {RdsData} + */ + + + setCT(ct) { + this.setParameter(RdsData.KEY_CT, ct); + return this; + } + /** + * @return {String} + */ + + + getCT() { + return this.getParameter(RdsData.KEY_CT); + } + /** + * @param {String} pi - Program Identification - the call sign for the radio station + * @return {RdsData} + */ + + + setPI(pi) { + this.setParameter(RdsData.KEY_PI, pi); + return this; + } + /** + * @return {String} + */ + + + getPI() { + return this.getParameter(RdsData.KEY_PI); + } + /** + * @param {Number} pty - The program type - The region should be used to differentiate between EU and North America + * program types + * @return {RdsData} + */ + + + setPTY(pty) { + this.setParameter(RdsData.KEY_PTY, pty); + return this; + } + /** + * @return {Number} + */ + + + getPTY() { + return this.getParameter(RdsData.KEY_PTY); + } + /** + * @param {Boolean} tp - Traffic Program Identification - Identifies a station that offers traffic + * @return {RdsData} + */ + + + setTP(tp) { + this.setParameter(RdsData.KEY_TP, tp); + return this; + } + /** + * @return {Boolean} + */ + + + getTP() { + return this.getParameter(RdsData.KEY_TP); + } + /** + * @param {Boolean} ta - Traffic Announcement Identification - Indicates an ongoing traffic announcement + * @return {RdsData} + */ + + + setTA(ta) { + this.setParameter(RdsData.KEY_TA, ta); + return this; + } + /** + * @return {Boolean} + */ + + + getTA() { + return this.getParameter(RdsData.KEY_TA); + } + /** + * @param {String} reg - Region + * @return {RdsData} + */ + + + setREG(reg) { + this.setParameter(RdsData.KEY_REG, reg); + return this; + } + /** + * @return {String} + */ + + + getREG() { + return this.getParameter(RdsData.KEY_REG); + } + + } + + RdsData.KEY_PS = 'PS'; + RdsData.KEY_RT = 'RT'; + RdsData.KEY_CT = 'CT'; + RdsData.KEY_PI = 'PI'; + RdsData.KEY_PTY = 'PTY'; + RdsData.KEY_TP = 'TP'; + RdsData.KEY_TA = 'TA'; + RdsData.KEY_REG = 'REG'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} RadioState + * @property {Object} _MAP + */ + + class RadioState extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get ACQUIRING() { + return RadioState._MAP.ACQUIRING; + } + /** + * @return {String} + */ + + + static get ACQUIRED() { + return RadioState._MAP.ACQUIRED; + } + /** + * @return {String} + */ + + + static get MULTICAST() { + return RadioState._MAP.MULTICAST; + } + /** + * @return {String} + */ + + + static get NOT_FOUND() { + return RadioState._MAP.NOT_FOUND; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return RadioState._valueForKey(key, RadioState._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return RadioState._keyForValue(value, RadioState._MAP); + } + + } + + RadioState._MAP = Object.freeze({ + 'ACQUIRING': 'ACQUIRING', + 'ACQUIRED': 'ACQUIRED', + 'MULTICAST': 'MULTICAST', + 'NOT_FOUND': 'NOT_FOUND' + }); + + /* eslint-disable camelcase */ + + class StationIDNumber extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} code - Binary Representation of ITU Country Code. USA Code is 001. + * @return {StationIDNumber} + */ + + + setCountryCode(code) { + this.setParameter(StationIDNumber.KEY_COUNTRY_CODE, code); + return this; + } + /** + * @return {Number} + */ + + + getCountryCode() { + return this.getParameter(StationIDNumber.KEY_COUNTRY_CODE); + } + /** + * @param {Number} id - Binary representation of unique facility ID assigned by the FCC; FCC controlled for U.S. + * territory + * @return {StationIDNumber} + */ + + + setFccFacilityId(id) { + this.setParameter(StationIDNumber.KEY_FCC_FACILITY_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getFccFacilityId() { + return this.getParameter(StationIDNumber.KEY_FCC_FACILITY_ID); + } + + } + + StationIDNumber.KEY_COUNTRY_CODE = 'countryCode'; + StationIDNumber.KEY_FCC_FACILITY_ID = 'fccFacilityId'; + + /* eslint-disable camelcase */ + + class SisData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - Identifies the 4-alpha-character station call sign plus an optional (-FM) extension + * @return {SisData} + */ + + + setStationShortName(name) { + this.setParameter(SisData.KEY_STATION_SHORT_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getStationShortName() { + return this.getParameter(SisData.KEY_STATION_SHORT_NAME); + } + /** + * @param {StationIDNumber} number - Used for network Application. Consists of Country Code and FCC Facility ID. + * @return {SisData} + */ + + + setStationIDNumber(number) { + this.validateType(StationIDNumber, number); + this.setParameter(SisData.KEY_STATION_IDNUMBER, number); + return this; + } + /** + * @return {StationIDNumber} + */ + + + getStationIDNumber() { + return this.getObject(StationIDNumber, SisData.KEY_STATION_IDNUMBER); + } + /** + * @param {String} name - Identifies the station call sign or other identifying information in the long format. + * @return {SisData} + */ + + + setStationLongName(name) { + this.setParameter(SisData.KEY_STATION_LONG_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getStationLongName() { + return this.getParameter(SisData.KEY_STATION_LONG_NAME); + } + /** + * @param {GPSData} location - Provides the 3-dimensional geographic station location. + * @return {SisData} + */ + + + setStationLocation(location) { + this.validateType(GPSData, location); + this.setParameter(SisData.KEY_STATION_LOCATION, location); + return this; + } + /** + * @return {GPSData} + */ + + + getStationLocation() { + return this.getObject(GPSData, SisData.KEY_STATION_LOCATION); + } + /** + * @param {String} message - May be used to convey textual information of general interest to the consumer such as + * weather forecasts or public service announcements. Includes a high priority delivery + * feature to convey emergencies that may be in the listening area. + * @return {SisData} + */ + + + setStationMessage(message) { + this.setParameter(SisData.KEY_STATION_MESSAGE, message); + return this; + } + /** + * @return {String} + */ + + + getStationMessage() { + return this.getParameter(SisData.KEY_STATION_MESSAGE); + } + + } + + SisData.KEY_STATION_SHORT_NAME = 'stationShortName'; + SisData.KEY_STATION_IDNUMBER = 'stationIDNumber'; + SisData.KEY_STATION_LONG_NAME = 'stationLongName'; + SisData.KEY_STATION_LOCATION = 'stationLocation'; + SisData.KEY_STATION_MESSAGE = 'stationMessage'; + + /* eslint-disable camelcase */ + + class RadioControlData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} integer - The integer part of the frequency ie for 101.7 this value should be 101 + * @return {RadioControlData} + */ + + + setFrequencyInteger(integer) { + this.setParameter(RadioControlData.KEY_FREQUENCY_INTEGER, integer); + return this; + } + /** + * @return {Number} + */ + + + getFrequencyInteger() { + return this.getParameter(RadioControlData.KEY_FREQUENCY_INTEGER); + } + /** + * @param {Number} fraction - The fractional part of the frequency for 101.7 is 7 + * @return {RadioControlData} + */ + + + setFrequencyFraction(fraction) { + this.setParameter(RadioControlData.KEY_FREQUENCY_FRACTION, fraction); + return this; + } + /** + * @return {Number} + */ + + + getFrequencyFraction() { + return this.getParameter(RadioControlData.KEY_FREQUENCY_FRACTION); + } + /** + * @param {RadioBand} band + * @return {RadioControlData} + */ + + + setBand(band) { + this.validateType(RadioBand, band); + this.setParameter(RadioControlData.KEY_BAND, band); + return this; + } + /** + * @return {RadioBand} + */ + + + getBand() { + return this.getObject(RadioBand, RadioControlData.KEY_BAND); + } + /** + * @param {RdsData} data + * @return {RadioControlData} + */ + + + setRdsData(data) { + this.validateType(RdsData, data); + this.setParameter(RadioControlData.KEY_RDS_DATA, data); + return this; + } + /** + * @return {RdsData} + */ + + + getRdsData() { + return this.getObject(RdsData, RadioControlData.KEY_RDS_DATA); + } + /** + * @param {Boolean} enable - True if the hd radio is on, false if the radio is off + * @return {RadioControlData} + */ + + + setHdRadioEnable(enable) { + this.setParameter(RadioControlData.KEY_HD_RADIO_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getHdRadioEnable() { + return this.getParameter(RadioControlData.KEY_HD_RADIO_ENABLE); + } + /** + * @param {Number} ds - Number of HD sub-channels if available + * @return {RadioControlData} + */ + + + setAvailableHDs(ds) { + this.setParameter(RadioControlData.KEY_AVAILABLE_HDS, ds); + return this; + } + /** + * @return {Number} + */ + + + getAvailableHDs() { + return this.getParameter(RadioControlData.KEY_AVAILABLE_HDS); + } + /** + * @param {Number[]} channels - The list of available HD sub-channel indexes. Empty list means no Hd channel is + * available. Read-only. + * @return {RadioControlData} + */ + + + setAvailableHdChannels(channels) { + this.setParameter(RadioControlData.KEY_AVAILABLE_HD_CHANNELS, channels); + return this; + } + /** + * @return {Number[]} + */ + + + getAvailableHdChannels() { + return this.getParameter(RadioControlData.KEY_AVAILABLE_HD_CHANNELS); + } + /** + * @param {Number} channel - Current HD sub-channel if available + * @return {RadioControlData} + */ + + + setHdChannel(channel) { + this.setParameter(RadioControlData.KEY_HD_CHANNEL, channel); + return this; + } + /** + * @return {Number} + */ + + + getHdChannel() { + return this.getParameter(RadioControlData.KEY_HD_CHANNEL); + } + /** + * @param {Number} strength + * @return {RadioControlData} + */ + + + setSignalStrength(strength) { + this.setParameter(RadioControlData.KEY_SIGNAL_STRENGTH, strength); + return this; + } + /** + * @return {Number} + */ + + + getSignalStrength() { + return this.getParameter(RadioControlData.KEY_SIGNAL_STRENGTH); + } + /** + * @param {Number} threshold - If the signal strength falls below the set value for this parameter, the radio will + * tune to an alternative frequency + * @return {RadioControlData} + */ + + + setSignalChangeThreshold(threshold) { + this.setParameter(RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD, threshold); + return this; + } + /** + * @return {Number} + */ + + + getSignalChangeThreshold() { + return this.getParameter(RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD); + } + /** + * @param {Boolean} enable - True if the radio is on, false if the radio is off. If set to false, no other data will + * be included. + * @return {RadioControlData} + */ + + + setRadioEnable(enable) { + this.setParameter(RadioControlData.KEY_RADIO_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getRadioEnable() { + return this.getParameter(RadioControlData.KEY_RADIO_ENABLE); + } + /** + * @param {RadioState} state + * @return {RadioControlData} + */ + + + setState(state) { + this.validateType(RadioState, state); + this.setParameter(RadioControlData.KEY_STATE, state); + return this; + } + /** + * @return {RadioState} + */ + + + getState() { + return this.getObject(RadioState, RadioControlData.KEY_STATE); + } + /** + * @param {SisData} data - Read-only Station Information Service (SIS) data provides basic information about the + * station such as call sign, as well as information not displayable to the consumer such as + * the station identification number + * @return {RadioControlData} + */ + + + setSisData(data) { + this.validateType(SisData, data); + this.setParameter(RadioControlData.KEY_SIS_DATA, data); + return this; + } + /** + * @return {SisData} + */ + + + getSisData() { + return this.getObject(SisData, RadioControlData.KEY_SIS_DATA); + } + + } + + RadioControlData.KEY_FREQUENCY_INTEGER = 'frequencyInteger'; + RadioControlData.KEY_FREQUENCY_FRACTION = 'frequencyFraction'; + RadioControlData.KEY_BAND = 'band'; + RadioControlData.KEY_RDS_DATA = 'rdsData'; + RadioControlData.KEY_HD_RADIO_ENABLE = 'hdRadioEnable'; + RadioControlData.KEY_AVAILABLE_HDS = 'availableHDs'; + RadioControlData.KEY_AVAILABLE_HD_CHANNELS = 'availableHdChannels'; + RadioControlData.KEY_HD_CHANNEL = 'hdChannel'; + RadioControlData.KEY_SIGNAL_STRENGTH = 'signalStrength'; + RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD = 'signalChangeThreshold'; + RadioControlData.KEY_RADIO_ENABLE = 'radioEnable'; + RadioControlData.KEY_STATE = 'state'; + RadioControlData.KEY_SIS_DATA = 'sisData'; + + /* eslint-disable camelcase */ + + class Temperature extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {TemperatureUnit} unit - Temperature Unit + * @return {Temperature} + */ + + + setUnit(unit) { + this.validateType(TemperatureUnit, unit); + this.setParameter(Temperature.KEY_UNIT, unit); + return this; + } + /** + * @return {TemperatureUnit} + */ + + + getUnit() { + return this.getObject(TemperatureUnit, Temperature.KEY_UNIT); + } + /** + * @param {Number} value - Temperature Value in TemperatureUnit specified unit. Range depends on OEM and is not + * checked by SDL. + * @return {Temperature} + */ + + + setValue(value) { + this.setParameter(Temperature.KEY_VALUE, value); + return this; + } + /** + * @return {Number} + */ + + + getValue() { + return this.getParameter(Temperature.KEY_VALUE); + } + + } + + Temperature.KEY_UNIT = 'unit'; + Temperature.KEY_VALUE = 'value'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} VentilationMode + * @property {Object} _MAP + */ + + class VentilationMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get UPPER() { + return VentilationMode._MAP.UPPER; + } + /** + * @return {String} + */ + + + static get LOWER() { + return VentilationMode._MAP.LOWER; + } + /** + * @return {String} + */ + + + static get BOTH() { + return VentilationMode._MAP.BOTH; + } + /** + * @return {String} + */ + + + static get NONE() { + return VentilationMode._MAP.NONE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VentilationMode._valueForKey(key, VentilationMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VentilationMode._keyForValue(value, VentilationMode._MAP); + } + + } + + VentilationMode._MAP = Object.freeze({ + 'UPPER': 'UPPER', + 'LOWER': 'LOWER', + 'BOTH': 'BOTH', + 'NONE': 'NONE' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} DefrostZone + * @property {Object} _MAP + */ + + class DefrostZone extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get FRONT() { + return DefrostZone._MAP.FRONT; + } + /** + * @return {String} + */ + + + static get REAR() { + return DefrostZone._MAP.REAR; + } + /** + * @return {String} + */ + + + static get ALL() { + return DefrostZone._MAP.ALL; + } + /** + * @return {String} + */ + + + static get NONE() { + return DefrostZone._MAP.NONE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return DefrostZone._valueForKey(key, DefrostZone._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return DefrostZone._keyForValue(value, DefrostZone._MAP); + } + + } + + DefrostZone._MAP = Object.freeze({ + 'FRONT': 'FRONT', + 'REAR': 'REAR', + 'ALL': 'ALL', + 'NONE': 'NONE' + }); + + /* eslint-disable camelcase */ + + class ClimateControlData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} speed + * @return {ClimateControlData} + */ + + + setFanSpeed(speed) { + this.setParameter(ClimateControlData.KEY_FAN_SPEED, speed); + return this; + } + /** + * @return {Number} + */ + + + getFanSpeed() { + return this.getParameter(ClimateControlData.KEY_FAN_SPEED); + } + /** + * @param {Temperature} temperature + * @return {ClimateControlData} + */ + + + setCurrentTemperature(temperature) { + this.validateType(Temperature, temperature); + this.setParameter(ClimateControlData.KEY_CURRENT_TEMPERATURE, temperature); + return this; + } + /** + * @return {Temperature} + */ + + + getCurrentTemperature() { + return this.getObject(Temperature, ClimateControlData.KEY_CURRENT_TEMPERATURE); + } + /** + * @param {Temperature} temperature + * @return {ClimateControlData} + */ + + + setDesiredTemperature(temperature) { + this.validateType(Temperature, temperature); + this.setParameter(ClimateControlData.KEY_DESIRED_TEMPERATURE, temperature); + return this; + } + /** + * @return {Temperature} + */ + + + getDesiredTemperature() { + return this.getObject(Temperature, ClimateControlData.KEY_DESIRED_TEMPERATURE); + } + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + + + setAcEnable(enable) { + this.setParameter(ClimateControlData.KEY_AC_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getAcEnable() { + return this.getParameter(ClimateControlData.KEY_AC_ENABLE); + } + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + + + setCirculateAirEnable(enable) { + this.setParameter(ClimateControlData.KEY_CIRCULATE_AIR_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getCirculateAirEnable() { + return this.getParameter(ClimateControlData.KEY_CIRCULATE_AIR_ENABLE); + } + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + + + setAutoModeEnable(enable) { + this.setParameter(ClimateControlData.KEY_AUTO_MODE_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getAutoModeEnable() { + return this.getParameter(ClimateControlData.KEY_AUTO_MODE_ENABLE); + } + /** + * @param {DefrostZone} zone + * @return {ClimateControlData} + */ + + + setDefrostZone(zone) { + this.validateType(DefrostZone, zone); + this.setParameter(ClimateControlData.KEY_DEFROST_ZONE, zone); + return this; + } + /** + * @return {DefrostZone} + */ + + + getDefrostZone() { + return this.getObject(DefrostZone, ClimateControlData.KEY_DEFROST_ZONE); + } + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + + + setDualModeEnable(enable) { + this.setParameter(ClimateControlData.KEY_DUAL_MODE_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getDualModeEnable() { + return this.getParameter(ClimateControlData.KEY_DUAL_MODE_ENABLE); + } + /** + * @param {Boolean} enable + * @return {ClimateControlData} + */ + + + setAcMaxEnable(enable) { + this.setParameter(ClimateControlData.KEY_AC_MAX_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getAcMaxEnable() { + return this.getParameter(ClimateControlData.KEY_AC_MAX_ENABLE); + } + /** + * @param {VentilationMode} mode + * @return {ClimateControlData} + */ + + + setVentilationMode(mode) { + this.validateType(VentilationMode, mode); + this.setParameter(ClimateControlData.KEY_VENTILATION_MODE, mode); + return this; + } + /** + * @return {VentilationMode} + */ + + + getVentilationMode() { + return this.getObject(VentilationMode, ClimateControlData.KEY_VENTILATION_MODE); + } + /** + * @param {Boolean} enable - value false means disabled/turn off, value true means enabled/turn on. + * @return {ClimateControlData} + */ + + + setHeatedSteeringWheelEnable(enable) { + this.setParameter(ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedSteeringWheelEnable() { + return this.getParameter(ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE); + } + /** + * @param {Boolean} enable - value false means disabled, value true means enabled. + * @return {ClimateControlData} + */ + + + setHeatedWindshieldEnable(enable) { + this.setParameter(ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedWindshieldEnable() { + return this.getParameter(ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE); + } + /** + * @param {Boolean} enable - value false means disabled, value true means enabled. + * @return {ClimateControlData} + */ + + + setHeatedRearWindowEnable(enable) { + this.setParameter(ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedRearWindowEnable() { + return this.getParameter(ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE); + } + /** + * @param {Boolean} enable - value false means disabled, value true means enabled. + * @return {ClimateControlData} + */ + + + setHeatedMirrorsEnable(enable) { + this.setParameter(ClimateControlData.KEY_HEATED_MIRRORS_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedMirrorsEnable() { + return this.getParameter(ClimateControlData.KEY_HEATED_MIRRORS_ENABLE); + } + /** + * @param {Boolean} enable - True if the climate module is on, false if the climate module is off + * @return {ClimateControlData} + */ + + + setClimateEnable(enable) { + this.setParameter(ClimateControlData.KEY_CLIMATE_ENABLE, enable); + return this; + } + /** + * @return {Boolean} + */ + + + getClimateEnable() { + return this.getParameter(ClimateControlData.KEY_CLIMATE_ENABLE); + } + + } + + ClimateControlData.KEY_FAN_SPEED = 'fanSpeed'; + ClimateControlData.KEY_CURRENT_TEMPERATURE = 'currentTemperature'; + ClimateControlData.KEY_DESIRED_TEMPERATURE = 'desiredTemperature'; + ClimateControlData.KEY_AC_ENABLE = 'acEnable'; + ClimateControlData.KEY_CIRCULATE_AIR_ENABLE = 'circulateAirEnable'; + ClimateControlData.KEY_AUTO_MODE_ENABLE = 'autoModeEnable'; + ClimateControlData.KEY_DEFROST_ZONE = 'defrostZone'; + ClimateControlData.KEY_DUAL_MODE_ENABLE = 'dualModeEnable'; + ClimateControlData.KEY_AC_MAX_ENABLE = 'acMaxEnable'; + ClimateControlData.KEY_VENTILATION_MODE = 'ventilationMode'; + ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE = 'heatedSteeringWheelEnable'; + ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE = 'heatedWindshieldEnable'; + ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE = 'heatedRearWindowEnable'; + ClimateControlData.KEY_HEATED_MIRRORS_ENABLE = 'heatedMirrorsEnable'; + ClimateControlData.KEY_CLIMATE_ENABLE = 'climateEnable'; + + /* eslint-disable camelcase */ + /** + * Defines the each Equalizer channel settings. + */ + + class EqualizerSettings extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} id + * @return {EqualizerSettings} + */ + + + setChannelId(id) { + this.setParameter(EqualizerSettings.KEY_CHANNEL_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getChannelId() { + return this.getParameter(EqualizerSettings.KEY_CHANNEL_ID); + } + /** + * @param {String} name - read-only channel / frequency name (e.i. "Treble, Midrange, Bass" or "125 Hz") + * @return {EqualizerSettings} + */ + + + setChannelName(name) { + this.setParameter(EqualizerSettings.KEY_CHANNEL_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getChannelName() { + return this.getParameter(EqualizerSettings.KEY_CHANNEL_NAME); + } + /** + * @param {Number} setting - Reflects the setting, from 0%-100%. + * @return {EqualizerSettings} + */ + + + setChannelSetting(setting) { + this.setParameter(EqualizerSettings.KEY_CHANNEL_SETTING, setting); + return this; + } + /** + * @return {Number} + */ + + + getChannelSetting() { + return this.getParameter(EqualizerSettings.KEY_CHANNEL_SETTING); + } + + } + + EqualizerSettings.KEY_CHANNEL_ID = 'channelId'; + EqualizerSettings.KEY_CHANNEL_NAME = 'channelName'; + EqualizerSettings.KEY_CHANNEL_SETTING = 'channelSetting'; + + /* eslint-disable camelcase */ + + class AudioControlData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {PrimaryAudioSource} source - In a getter response or a notification, it is the current primary audio + * source of the system. In a setter request, it is the target audio source + * that the system shall switch to. If the value is MOBILE_APP, the system + * shall switch to the mobile media app that issues the setter RPC. + * @return {AudioControlData} + */ + + + setSource(source) { + this.validateType(PrimaryAudioSource, source); + this.setParameter(AudioControlData.KEY_SOURCE, source); + return this; + } + /** + * @return {PrimaryAudioSource} + */ + + + getSource() { + return this.getObject(PrimaryAudioSource, AudioControlData.KEY_SOURCE); + } + /** + * @param {Boolean} context - This parameter shall not be present in any getter responses or notifications. This + * parameter is optional in a setter request. The default value is false if it is not + * included. If it is false, the system not only changes the audio source but also brings + * the default application or system UI associated with the audio source to foreground. + * If it is true, the system only changes the audio source, but keeps the current + * application in foreground. + * @return {AudioControlData} + */ + + + setKeepContext(context) { + this.setParameter(AudioControlData.KEY_KEEP_CONTEXT, context); + return this; + } + /** + * @return {Boolean} + */ + + + getKeepContext() { + return this.getParameter(AudioControlData.KEY_KEEP_CONTEXT); + } + /** + * @param {Number} volume - Reflects the volume of audio, from 0%-100%. + * @return {AudioControlData} + */ + + + setVolume(volume) { + this.setParameter(AudioControlData.KEY_VOLUME, volume); + return this; + } + /** + * @return {Number} + */ + + + getVolume() { + return this.getParameter(AudioControlData.KEY_VOLUME); + } + /** + * @param {EqualizerSettings[]} settings - Defines the list of supported channels (band) and their current/desired + * settings on HMI + * @return {AudioControlData} + */ + + + setEqualizerSettings(settings) { + this.validateType(EqualizerSettings, settings, true); + this.setParameter(AudioControlData.KEY_EQUALIZER_SETTINGS, settings); + return this; + } + /** + * @return {EqualizerSettings[]} + */ + + + getEqualizerSettings() { + return this.getObject(EqualizerSettings, AudioControlData.KEY_EQUALIZER_SETTINGS); + } + + } + + AudioControlData.KEY_SOURCE = 'source'; + AudioControlData.KEY_KEEP_CONTEXT = 'keepContext'; + AudioControlData.KEY_VOLUME = 'volume'; + AudioControlData.KEY_EQUALIZER_SETTINGS = 'equalizerSettings'; + + /* eslint-disable camelcase */ + /** + * List possible cushions of a multi-contour massage seat. + * @typedef {Enum} MassageCushion + * @property {Object} _MAP + */ + + class MassageCushion extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get TOP_LUMBAR() { + return MassageCushion._MAP.TOP_LUMBAR; + } + /** + * @return {String} + */ + + + static get MIDDLE_LUMBAR() { + return MassageCushion._MAP.MIDDLE_LUMBAR; + } + /** + * @return {String} + */ + + + static get BOTTOM_LUMBAR() { + return MassageCushion._MAP.BOTTOM_LUMBAR; + } + /** + * @return {String} + */ + + + static get BACK_BOLSTERS() { + return MassageCushion._MAP.BACK_BOLSTERS; + } + /** + * @return {String} + */ + + + static get SEAT_BOLSTERS() { + return MassageCushion._MAP.SEAT_BOLSTERS; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return MassageCushion._valueForKey(key, MassageCushion._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return MassageCushion._keyForValue(value, MassageCushion._MAP); + } + + } + + MassageCushion._MAP = Object.freeze({ + 'TOP_LUMBAR': 'TOP_LUMBAR', + 'MIDDLE_LUMBAR': 'MIDDLE_LUMBAR', + 'BOTTOM_LUMBAR': 'BOTTOM_LUMBAR', + 'BACK_BOLSTERS': 'BACK_BOLSTERS', + 'SEAT_BOLSTERS': 'SEAT_BOLSTERS' + }); + + /* eslint-disable camelcase */ + /** + * The intensity or firmness of a cushion. + */ + + class MassageCushionFirmness extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {MassageCushion} cushion - List possible cushions of a multi-contour massage seat. + * @return {MassageCushionFirmness} + */ + + + setCushion(cushion) { + this.validateType(MassageCushion, cushion); + this.setParameter(MassageCushionFirmness.KEY_CUSHION, cushion); + return this; + } + /** + * @return {MassageCushion} + */ + + + getCushion() { + return this.getObject(MassageCushion, MassageCushionFirmness.KEY_CUSHION); + } + /** + * @param {Number} firmness + * @return {MassageCushionFirmness} + */ + + + setFirmness(firmness) { + this.setParameter(MassageCushionFirmness.KEY_FIRMNESS, firmness); + return this; + } + /** + * @return {Number} + */ + + + getFirmness() { + return this.getParameter(MassageCushionFirmness.KEY_FIRMNESS); + } + + } + + MassageCushionFirmness.KEY_CUSHION = 'cushion'; + MassageCushionFirmness.KEY_FIRMNESS = 'firmness'; + + /* eslint-disable camelcase */ + /** + * List possible seats that is a remote controllable seat. + * @deprecated + * @typedef {Enum} SupportedSeat + * @property {Object} _MAP + */ + + class SupportedSeat extends Enum { + /** + * @deprecated + * @constructor + */ + constructor() { + super(); + } + /** + * @deprecated + * @return {String} + */ + + + static get DRIVER() { + return SupportedSeat._MAP.DRIVER; + } + /** + * @deprecated + * @return {String} + */ + + + static get FRONT_PASSENGER() { + return SupportedSeat._MAP.FRONT_PASSENGER; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return SupportedSeat._valueForKey(key, SupportedSeat._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return SupportedSeat._keyForValue(value, SupportedSeat._MAP); + } + + } + + SupportedSeat._MAP = Object.freeze({ + 'DRIVER': 'DRIVER', + 'FRONT_PASSENGER': 'FRONT_PASSENGER' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} SeatMemoryActionType + * @property {Object} _MAP + */ + + class SeatMemoryActionType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Save current seat postions and settings to seat memory. + * @return {String} + */ + + + static get SAVE() { + return SeatMemoryActionType._MAP.SAVE; + } + /** + * Restore / apply the seat memory settings to the current seat. + * @return {String} + */ + + + static get RESTORE() { + return SeatMemoryActionType._MAP.RESTORE; + } + /** + * No action to be performed. + * @return {String} + */ + + + static get NONE() { + return SeatMemoryActionType._MAP.NONE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return SeatMemoryActionType._valueForKey(key, SeatMemoryActionType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return SeatMemoryActionType._keyForValue(value, SeatMemoryActionType._MAP); + } + + } + + SeatMemoryActionType._MAP = Object.freeze({ + 'SAVE': 'SAVE', + 'RESTORE': 'RESTORE', + 'NONE': 'NONE' + }); + + /* eslint-disable camelcase */ + + class SeatMemoryAction extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} id + * @return {SeatMemoryAction} + */ + + + setId(id) { + this.setParameter(SeatMemoryAction.KEY_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getId() { + return this.getParameter(SeatMemoryAction.KEY_ID); + } + /** + * @param {String} label + * @return {SeatMemoryAction} + */ + + + setLabel(label) { + this.setParameter(SeatMemoryAction.KEY_LABEL, label); + return this; + } + /** + * @return {String} + */ + + + getLabel() { + return this.getParameter(SeatMemoryAction.KEY_LABEL); + } + /** + * @param {SeatMemoryActionType} action + * @return {SeatMemoryAction} + */ + + + setAction(action) { + this.validateType(SeatMemoryActionType, action); + this.setParameter(SeatMemoryAction.KEY_ACTION, action); + return this; + } + /** + * @return {SeatMemoryActionType} + */ + + + getAction() { + return this.getObject(SeatMemoryActionType, SeatMemoryAction.KEY_ACTION); + } + + } + + SeatMemoryAction.KEY_ID = 'id'; + SeatMemoryAction.KEY_LABEL = 'label'; + SeatMemoryAction.KEY_ACTION = 'action'; + + /* eslint-disable camelcase */ + /** + * List possible zones of a multi-contour massage seat. + * @typedef {Enum} MassageZone + * @property {Object} _MAP + */ + + class MassageZone extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * The back of a multi-contour massage seat. or SEAT_BACK + * @return {String} + */ + + + static get LUMBAR() { + return MassageZone._MAP.LUMBAR; + } + /** + * The bottom a multi-contour massage seat. or SEAT_BOTTOM + * @return {String} + */ + + + static get SEAT_CUSHION() { + return MassageZone._MAP.SEAT_CUSHION; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return MassageZone._valueForKey(key, MassageZone._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return MassageZone._keyForValue(value, MassageZone._MAP); + } + + } + + MassageZone._MAP = Object.freeze({ + 'LUMBAR': 'LUMBAR', + 'SEAT_CUSHION': 'SEAT_CUSHION' + }); + + /* eslint-disable camelcase */ + /** + * List possible modes of a massage zone. + * @typedef {Enum} MassageMode + * @property {Object} _MAP + */ + + class MassageMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get OFF() { + return MassageMode._MAP.OFF; + } + /** + * @return {String} + */ + + + static get LOW() { + return MassageMode._MAP.LOW; + } + /** + * @return {String} + */ + + + static get HIGH() { + return MassageMode._MAP.HIGH; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return MassageMode._valueForKey(key, MassageMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return MassageMode._keyForValue(value, MassageMode._MAP); + } + + } + + MassageMode._MAP = Object.freeze({ + 'OFF': 'OFF', + 'LOW': 'LOW', + 'HIGH': 'HIGH' + }); + + /* eslint-disable camelcase */ + /** + * Specify the mode of a massage zone. + */ + + class MassageModeData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {MassageZone} zone - List possible zones of a multi-contour massage seat. + * @return {MassageModeData} + */ + + + setMassageZone(zone) { + this.validateType(MassageZone, zone); + this.setParameter(MassageModeData.KEY_MASSAGE_ZONE, zone); + return this; + } + /** + * @return {MassageZone} + */ + + + getMassageZone() { + return this.getObject(MassageZone, MassageModeData.KEY_MASSAGE_ZONE); + } + /** + * @param {MassageMode} mode - List possible modes of a massage zone. + * @return {MassageModeData} + */ + + + setMassageMode(mode) { + this.validateType(MassageMode, mode); + this.setParameter(MassageModeData.KEY_MASSAGE_MODE, mode); + return this; + } + /** + * @return {MassageMode} + */ + + + getMassageMode() { + return this.getObject(MassageMode, MassageModeData.KEY_MASSAGE_MODE); + } + + } + + MassageModeData.KEY_MASSAGE_ZONE = 'massageZone'; + MassageModeData.KEY_MASSAGE_MODE = 'massageMode'; + + /* eslint-disable camelcase */ + /** + * Seat control data corresponds to "SEAT" ModuleType. + */ + + class SeatControlData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {SupportedSeat} id - List possible seats that is a remote controllable seat. + * @return {SeatControlData} + */ + + + setId(id) { + this.validateType(SupportedSeat, id); + this.setParameter(SeatControlData.KEY_ID, id); + return this; + } + /** + * @return {SupportedSeat} + */ + + + getId() { + return this.getObject(SupportedSeat, SeatControlData.KEY_ID); + } + /** + * @param {Boolean} enabled + * @return {SeatControlData} + */ + + + setHeatingEnabled(enabled) { + this.setParameter(SeatControlData.KEY_HEATING_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatingEnabled() { + return this.getParameter(SeatControlData.KEY_HEATING_ENABLED); + } + /** + * @param {Boolean} enabled + * @return {SeatControlData} + */ + + + setCoolingEnabled(enabled) { + this.setParameter(SeatControlData.KEY_COOLING_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getCoolingEnabled() { + return this.getParameter(SeatControlData.KEY_COOLING_ENABLED); + } + /** + * @param {Number} level + * @return {SeatControlData} + */ + + + setHeatingLevel(level) { + this.setParameter(SeatControlData.KEY_HEATING_LEVEL, level); + return this; + } + /** + * @return {Number} + */ + + + getHeatingLevel() { + return this.getParameter(SeatControlData.KEY_HEATING_LEVEL); + } + /** + * @param {Number} level + * @return {SeatControlData} + */ + + + setCoolingLevel(level) { + this.setParameter(SeatControlData.KEY_COOLING_LEVEL, level); + return this; + } + /** + * @return {Number} + */ + + + getCoolingLevel() { + return this.getParameter(SeatControlData.KEY_COOLING_LEVEL); + } + /** + * @param {Number} position + * @return {SeatControlData} + */ + + + setHorizontalPosition(position) { + this.setParameter(SeatControlData.KEY_HORIZONTAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getHorizontalPosition() { + return this.getParameter(SeatControlData.KEY_HORIZONTAL_POSITION); + } + /** + * @param {Number} position + * @return {SeatControlData} + */ + + + setVerticalPosition(position) { + this.setParameter(SeatControlData.KEY_VERTICAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getVerticalPosition() { + return this.getParameter(SeatControlData.KEY_VERTICAL_POSITION); + } + /** + * @param {Number} position + * @return {SeatControlData} + */ + + + setFrontVerticalPosition(position) { + this.setParameter(SeatControlData.KEY_FRONT_VERTICAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getFrontVerticalPosition() { + return this.getParameter(SeatControlData.KEY_FRONT_VERTICAL_POSITION); + } + /** + * @param {Number} position + * @return {SeatControlData} + */ + + + setBackVerticalPosition(position) { + this.setParameter(SeatControlData.KEY_BACK_VERTICAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getBackVerticalPosition() { + return this.getParameter(SeatControlData.KEY_BACK_VERTICAL_POSITION); + } + /** + * @param {Number} angle + * @return {SeatControlData} + */ + + + setBackTiltAngle(angle) { + this.setParameter(SeatControlData.KEY_BACK_TILT_ANGLE, angle); + return this; + } + /** + * @return {Number} + */ + + + getBackTiltAngle() { + return this.getParameter(SeatControlData.KEY_BACK_TILT_ANGLE); + } + /** + * @param {Number} position + * @return {SeatControlData} + */ + + + setHeadSupportHorizontalPosition(position) { + this.setParameter(SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getHeadSupportHorizontalPosition() { + return this.getParameter(SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION); + } + /** + * @param {Number} position + * @return {SeatControlData} + */ + + + setHeadSupportVerticalPosition(position) { + this.setParameter(SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getHeadSupportVerticalPosition() { + return this.getParameter(SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION); + } + /** + * @param {Boolean} enabled + * @return {SeatControlData} + */ + + + setMassageEnabled(enabled) { + this.setParameter(SeatControlData.KEY_MASSAGE_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getMassageEnabled() { + return this.getParameter(SeatControlData.KEY_MASSAGE_ENABLED); + } + /** + * @param {MassageModeData[]} mode - Specify the mode of a massage zone. + * @return {SeatControlData} + */ + + + setMassageMode(mode) { + this.validateType(MassageModeData, mode, true); + this.setParameter(SeatControlData.KEY_MASSAGE_MODE, mode); + return this; + } + /** + * @return {MassageModeData[]} + */ + + + getMassageMode() { + return this.getObject(MassageModeData, SeatControlData.KEY_MASSAGE_MODE); + } + /** + * @param {MassageCushionFirmness[]} firmness - The intensity or firmness of a cushion. + * @return {SeatControlData} + */ + + + setMassageCushionFirmness(firmness) { + this.validateType(MassageCushionFirmness, firmness, true); + this.setParameter(SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS, firmness); + return this; + } + /** + * @return {MassageCushionFirmness[]} + */ + + + getMassageCushionFirmness() { + return this.getObject(MassageCushionFirmness, SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS); + } + /** + * @param {SeatMemoryAction} memory + * @return {SeatControlData} + */ + + + setMemory(memory) { + this.validateType(SeatMemoryAction, memory); + this.setParameter(SeatControlData.KEY_MEMORY, memory); + return this; + } + /** + * @return {SeatMemoryAction} + */ + + + getMemory() { + return this.getObject(SeatMemoryAction, SeatControlData.KEY_MEMORY); + } + + } + + SeatControlData.KEY_ID = 'id'; + SeatControlData.KEY_HEATING_ENABLED = 'heatingEnabled'; + SeatControlData.KEY_COOLING_ENABLED = 'coolingEnabled'; + SeatControlData.KEY_HEATING_LEVEL = 'heatingLevel'; + SeatControlData.KEY_COOLING_LEVEL = 'coolingLevel'; + SeatControlData.KEY_HORIZONTAL_POSITION = 'horizontalPosition'; + SeatControlData.KEY_VERTICAL_POSITION = 'verticalPosition'; + SeatControlData.KEY_FRONT_VERTICAL_POSITION = 'frontVerticalPosition'; + SeatControlData.KEY_BACK_VERTICAL_POSITION = 'backVerticalPosition'; + SeatControlData.KEY_BACK_TILT_ANGLE = 'backTiltAngle'; + SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION = 'headSupportHorizontalPosition'; + SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION = 'headSupportVerticalPosition'; + SeatControlData.KEY_MASSAGE_ENABLED = 'massageEnabled'; + SeatControlData.KEY_MASSAGE_MODE = 'massageMode'; + SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS = 'massageCushionFirmness'; + SeatControlData.KEY_MEMORY = 'memory'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} LightStatus + * @property {Object} _MAP + */ + + class LightStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get ON() { + return LightStatus._MAP.ON; + } + /** + * @return {String} + */ + + + static get OFF() { + return LightStatus._MAP.OFF; + } + /** + * @return {String} + */ + + + static get RAMP_UP() { + return LightStatus._MAP.RAMP_UP; + } + /** + * @return {String} + */ + + + static get RAMP_DOWN() { + return LightStatus._MAP.RAMP_DOWN; + } + /** + * @return {String} + */ + + + static get UNKNOWN() { + return LightStatus._MAP.UNKNOWN; + } + /** + * @return {String} + */ + + + static get INVALID() { + return LightStatus._MAP.INVALID; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return LightStatus._valueForKey(key, LightStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return LightStatus._keyForValue(value, LightStatus._MAP); + } + + } + + LightStatus._MAP = Object.freeze({ + 'ON': 'ON', + 'OFF': 'OFF', + 'RAMP_UP': 'RAMP_UP', + 'RAMP_DOWN': 'RAMP_DOWN', + 'UNKNOWN': 'UNKNOWN', + 'INVALID': 'INVALID' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} LightName + * @property {Object} _MAP + */ + + class LightName extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {Number} + */ + + + static get FRONT_LEFT_HIGH_BEAM() { + return LightName._MAP.FRONT_LEFT_HIGH_BEAM; + } + /** + * @return {Number} + */ + + + static get FRONT_RIGHT_HIGH_BEAM() { + return LightName._MAP.FRONT_RIGHT_HIGH_BEAM; + } + /** + * @return {Number} + */ + + + static get FRONT_LEFT_LOW_BEAM() { + return LightName._MAP.FRONT_LEFT_LOW_BEAM; + } + /** + * @return {Number} + */ + + + static get FRONT_RIGHT_LOW_BEAM() { + return LightName._MAP.FRONT_RIGHT_LOW_BEAM; + } + /** + * @return {Number} + */ + + + static get FRONT_LEFT_PARKING_LIGHT() { + return LightName._MAP.FRONT_LEFT_PARKING_LIGHT; + } + /** + * @return {Number} + */ + + + static get FRONT_RIGHT_PARKING_LIGHT() { + return LightName._MAP.FRONT_RIGHT_PARKING_LIGHT; + } + /** + * @return {Number} + */ + + + static get FRONT_LEFT_FOG_LIGHT() { + return LightName._MAP.FRONT_LEFT_FOG_LIGHT; + } + /** + * @return {Number} + */ + + + static get FRONT_RIGHT_FOG_LIGHT() { + return LightName._MAP.FRONT_RIGHT_FOG_LIGHT; + } + /** + * @return {Number} + */ + + + static get FRONT_LEFT_DAYTIME_RUNNING_LIGHT() { + return LightName._MAP.FRONT_LEFT_DAYTIME_RUNNING_LIGHT; + } + /** + * @return {Number} + */ + + + static get FRONT_RIGHT_DAYTIME_RUNNING_LIGHT() { + return LightName._MAP.FRONT_RIGHT_DAYTIME_RUNNING_LIGHT; + } + /** + * @return {Number} + */ + + + static get FRONT_LEFT_TURN_LIGHT() { + return LightName._MAP.FRONT_LEFT_TURN_LIGHT; + } + /** + * @return {Number} + */ + + + static get FRONT_RIGHT_TURN_LIGHT() { + return LightName._MAP.FRONT_RIGHT_TURN_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_LEFT_FOG_LIGHT() { + return LightName._MAP.REAR_LEFT_FOG_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_RIGHT_FOG_LIGHT() { + return LightName._MAP.REAR_RIGHT_FOG_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_LEFT_TAIL_LIGHT() { + return LightName._MAP.REAR_LEFT_TAIL_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_RIGHT_TAIL_LIGHT() { + return LightName._MAP.REAR_RIGHT_TAIL_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_LEFT_BRAKE_LIGHT() { + return LightName._MAP.REAR_LEFT_BRAKE_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_RIGHT_BRAKE_LIGHT() { + return LightName._MAP.REAR_RIGHT_BRAKE_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_LEFT_TURN_LIGHT() { + return LightName._MAP.REAR_LEFT_TURN_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_RIGHT_TURN_LIGHT() { + return LightName._MAP.REAR_RIGHT_TURN_LIGHT; + } + /** + * @return {Number} + */ + + + static get REAR_REGISTRATION_PLATE_LIGHT() { + return LightName._MAP.REAR_REGISTRATION_PLATE_LIGHT; + } + /** + * Include all high beam lights: front_left and front_right. + * @return {Number} + */ + + + static get HIGH_BEAMS() { + return LightName._MAP.HIGH_BEAMS; + } + /** + * Include all low beam lights: front_left and front_right. + * @return {Number} + */ + + + static get LOW_BEAMS() { + return LightName._MAP.LOW_BEAMS; + } + /** + * Include all fog lights: front_left, front_right, rear_left and rear_right. + * @return {Number} + */ + + + static get FOG_LIGHTS() { + return LightName._MAP.FOG_LIGHTS; + } + /** + * Include all daytime running lights: front_left and front_right. + * @return {Number} + */ + + + static get RUNNING_LIGHTS() { + return LightName._MAP.RUNNING_LIGHTS; + } + /** + * Include all parking lights: front_left and front_right. + * @return {Number} + */ + + + static get PARKING_LIGHTS() { + return LightName._MAP.PARKING_LIGHTS; + } + /** + * Include all brake lights: rear_left and rear_right. + * @return {Number} + */ + + + static get BRAKE_LIGHTS() { + return LightName._MAP.BRAKE_LIGHTS; + } + /** + * @return {Number} + */ + + + static get REAR_REVERSING_LIGHTS() { + return LightName._MAP.REAR_REVERSING_LIGHTS; + } + /** + * @return {Number} + */ + + + static get SIDE_MARKER_LIGHTS() { + return LightName._MAP.SIDE_MARKER_LIGHTS; + } + /** + * Include all left turn signal lights: front_left, rear_left, left_side and mirror_mounted. + * @return {Number} + */ + + + static get LEFT_TURN_LIGHTS() { + return LightName._MAP.LEFT_TURN_LIGHTS; + } + /** + * Include all right turn signal lights: front_right, rear_right, right_side and mirror_mounted. + * @return {Number} + */ + + + static get RIGHT_TURN_LIGHTS() { + return LightName._MAP.RIGHT_TURN_LIGHTS; + } + /** + * Include all hazard lights: front_left, front_right, rear_left and rear_right. + * @return {Number} + */ + + + static get HAZARD_LIGHTS() { + return LightName._MAP.HAZARD_LIGHTS; + } + /** + * Cargo lamps illuminate the cargo area. + * @return {Number} + */ + + + static get REAR_CARGO_LIGHTS() { + return LightName._MAP.REAR_CARGO_LIGHTS; + } + /** + * Truck bed lamps light up the bed of the truck. + * @return {Number} + */ + + + static get REAR_TRUCK_BED_LIGHTS() { + return LightName._MAP.REAR_TRUCK_BED_LIGHTS; + } + /** + * Trailer lights are lamps mounted on a trailer hitch. + * @return {Number} + */ + + + static get REAR_TRAILER_LIGHTS() { + return LightName._MAP.REAR_TRAILER_LIGHTS; + } + /** + * It is the spotlights mounted on the left side of a vehicle. + * @return {Number} + */ + + + static get LEFT_SPOT_LIGHTS() { + return LightName._MAP.LEFT_SPOT_LIGHTS; + } + /** + * It is the spotlights mounted on the right side of a vehicle. + * @return {Number} + */ + + + static get RIGHT_SPOT_LIGHTS() { + return LightName._MAP.RIGHT_SPOT_LIGHTS; + } + /** + * Puddle lamps illuminate the ground beside the door as the customer is opening or approaching the door. + * @return {Number} + */ + + + static get LEFT_PUDDLE_LIGHTS() { + return LightName._MAP.LEFT_PUDDLE_LIGHTS; + } + /** + * Puddle lamps illuminate the ground beside the door as the customer is opening or approaching the door. + * @return {Number} + */ + + + static get RIGHT_PUDDLE_LIGHTS() { + return LightName._MAP.RIGHT_PUDDLE_LIGHTS; + } + /** + * @return {Number} + */ + + + static get AMBIENT_LIGHTS() { + return LightName._MAP.AMBIENT_LIGHTS; + } + /** + * @return {Number} + */ + + + static get OVERHEAD_LIGHTS() { + return LightName._MAP.OVERHEAD_LIGHTS; + } + /** + * @return {Number} + */ + + + static get READING_LIGHTS() { + return LightName._MAP.READING_LIGHTS; + } + /** + * @return {Number} + */ + + + static get TRUNK_LIGHTS() { + return LightName._MAP.TRUNK_LIGHTS; + } + /** + * Include exterior lights located in front of the vehicle. For example, fog lights and low beams. + * @return {Number} + */ + + + static get EXTERIOR_FRONT_LIGHTS() { + return LightName._MAP.EXTERIOR_FRONT_LIGHTS; + } + /** + * Include exterior lights located at the back of the vehicle. For example, license plate lights, reverse lights, + * cargo lights, bed lights and trailer assist lights. + * @return {Number} + */ + + + static get EXTERIOR_REAR_LIGHTS() { + return LightName._MAP.EXTERIOR_REAR_LIGHTS; + } + /** + * Include exterior lights located at the left side of the vehicle. For example, left puddle lights and spot + * lights. + * @return {Number} + */ + + + static get EXTERIOR_LEFT_LIGHTS() { + return LightName._MAP.EXTERIOR_LEFT_LIGHTS; + } + /** + * Include exterior lights located at the right side of the vehicle. For example, right puddle lights and spot + * lights. + * @return {Number} + */ + + + static get EXTERIOR_RIGHT_LIGHTS() { + return LightName._MAP.EXTERIOR_RIGHT_LIGHTS; + } + /** + * Include all exterior lights around the vehicle. + * @return {Number} + */ + + + static get EXTERIOR_ALL_LIGHTS() { + return LightName._MAP.EXTERIOR_ALL_LIGHTS; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return LightName._valueForKey(key, LightName._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return LightName._keyForValue(value, LightName._MAP); + } + + } + + LightName._MAP = Object.freeze({ + 'FRONT_LEFT_HIGH_BEAM': 0, + 'FRONT_RIGHT_HIGH_BEAM': 1, + 'FRONT_LEFT_LOW_BEAM': 2, + 'FRONT_RIGHT_LOW_BEAM': 3, + 'FRONT_LEFT_PARKING_LIGHT': 4, + 'FRONT_RIGHT_PARKING_LIGHT': 5, + 'FRONT_LEFT_FOG_LIGHT': 6, + 'FRONT_RIGHT_FOG_LIGHT': 7, + 'FRONT_LEFT_DAYTIME_RUNNING_LIGHT': 8, + 'FRONT_RIGHT_DAYTIME_RUNNING_LIGHT': 9, + 'FRONT_LEFT_TURN_LIGHT': 10, + 'FRONT_RIGHT_TURN_LIGHT': 11, + 'REAR_LEFT_FOG_LIGHT': 12, + 'REAR_RIGHT_FOG_LIGHT': 13, + 'REAR_LEFT_TAIL_LIGHT': 14, + 'REAR_RIGHT_TAIL_LIGHT': 15, + 'REAR_LEFT_BRAKE_LIGHT': 16, + 'REAR_RIGHT_BRAKE_LIGHT': 17, + 'REAR_LEFT_TURN_LIGHT': 18, + 'REAR_RIGHT_TURN_LIGHT': 19, + 'REAR_REGISTRATION_PLATE_LIGHT': 20, + 'HIGH_BEAMS': 501, + 'LOW_BEAMS': 502, + 'FOG_LIGHTS': 503, + 'RUNNING_LIGHTS': 504, + 'PARKING_LIGHTS': 505, + 'BRAKE_LIGHTS': 506, + 'REAR_REVERSING_LIGHTS': 507, + 'SIDE_MARKER_LIGHTS': 508, + 'LEFT_TURN_LIGHTS': 509, + 'RIGHT_TURN_LIGHTS': 510, + 'HAZARD_LIGHTS': 511, + 'REAR_CARGO_LIGHTS': 512, + 'REAR_TRUCK_BED_LIGHTS': 513, + 'REAR_TRAILER_LIGHTS': 514, + 'LEFT_SPOT_LIGHTS': 515, + 'RIGHT_SPOT_LIGHTS': 516, + 'LEFT_PUDDLE_LIGHTS': 517, + 'RIGHT_PUDDLE_LIGHTS': 518, + 'AMBIENT_LIGHTS': 801, + 'OVERHEAD_LIGHTS': 802, + 'READING_LIGHTS': 803, + 'TRUNK_LIGHTS': 804, + 'EXTERIOR_FRONT_LIGHTS': 901, + 'EXTERIOR_REAR_LIGHTS': 902, + 'EXTERIOR_LEFT_LIGHTS': 903, + 'EXTERIOR_RIGHT_LIGHTS': 904, + 'EXTERIOR_ALL_LIGHTS': 905 + }); + + /* eslint-disable camelcase */ + + class LightState extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {LightName} id - The name of a light or a group of lights. + * @return {LightState} + */ + + + setId(id) { + this.validateType(LightName, id); + this.setParameter(LightState.KEY_ID, id); + return this; + } + /** + * @return {LightName} + */ + + + getId() { + return this.getObject(LightName, LightState.KEY_ID); + } + /** + * @param {LightStatus} status + * @return {LightState} + */ + + + setStatus(status) { + this.validateType(LightStatus, status); + this.setParameter(LightState.KEY_STATUS, status); + return this; + } + /** + * @return {LightStatus} + */ + + + getStatus() { + return this.getObject(LightStatus, LightState.KEY_STATUS); + } + /** + * @param {Number} density + * @return {LightState} + */ + + + setDensity(density) { + this.setParameter(LightState.KEY_DENSITY, density); + return this; + } + /** + * @return {Number} + */ + + + getDensity() { + return this.getParameter(LightState.KEY_DENSITY); + } + /** + * @param {RGBColor} color + * @return {LightState} + */ + + + setColor(color) { + this.validateType(RGBColor, color); + this.setParameter(LightState.KEY_COLOR, color); + return this; + } + /** + * @return {RGBColor} + */ + + + getColor() { + return this.getObject(RGBColor, LightState.KEY_COLOR); + } + + } + + LightState.KEY_ID = 'id'; + LightState.KEY_STATUS = 'status'; + LightState.KEY_DENSITY = 'density'; + LightState.KEY_COLOR = 'color'; + + /* eslint-disable camelcase */ + + class LightControlData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {LightState[]} state - An array of LightNames and their current or desired status. No change to the status + * of the LightNames that are not listed in the array. + * @return {LightControlData} + */ + + + setLightState(state) { + this.validateType(LightState, state, true); + this.setParameter(LightControlData.KEY_LIGHT_STATE, state); + return this; + } + /** + * @return {LightState[]} + */ + + + getLightState() { + return this.getObject(LightState, LightControlData.KEY_LIGHT_STATE); + } + + } + + LightControlData.KEY_LIGHT_STATE = 'lightState'; + + /* eslint-disable camelcase */ + /** + * The moduleType indicates which type of data should be changed and identifies which data object exists in this + * struct. For example, if the moduleType is CLIMATE then a "climateControlData" should exist + */ + + class ModuleData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {ModuleType} type + * @return {ModuleData} + */ + + + setModuleType(type) { + this.validateType(ModuleType, type); + this.setParameter(ModuleData.KEY_MODULE_TYPE, type); + return this; + } + /** + * @return {ModuleType} + */ + + + getModuleType() { + return this.getObject(ModuleType, ModuleData.KEY_MODULE_TYPE); + } + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {ModuleData} + */ + + + setModuleId(id) { + this.setParameter(ModuleData.KEY_MODULE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getModuleId() { + return this.getParameter(ModuleData.KEY_MODULE_ID); + } + /** + * @param {RadioControlData} data + * @return {ModuleData} + */ + + + setRadioControlData(data) { + this.validateType(RadioControlData, data); + this.setParameter(ModuleData.KEY_RADIO_CONTROL_DATA, data); + return this; + } + /** + * @return {RadioControlData} + */ + + + getRadioControlData() { + return this.getObject(RadioControlData, ModuleData.KEY_RADIO_CONTROL_DATA); + } + /** + * @param {ClimateControlData} data + * @return {ModuleData} + */ + + + setClimateControlData(data) { + this.validateType(ClimateControlData, data); + this.setParameter(ModuleData.KEY_CLIMATE_CONTROL_DATA, data); + return this; + } + /** + * @return {ClimateControlData} + */ + + + getClimateControlData() { + return this.getObject(ClimateControlData, ModuleData.KEY_CLIMATE_CONTROL_DATA); + } + /** + * @param {SeatControlData} data - Seat control data corresponds to "SEAT" ModuleType. + * @return {ModuleData} + */ + + + setSeatControlData(data) { + this.validateType(SeatControlData, data); + this.setParameter(ModuleData.KEY_SEAT_CONTROL_DATA, data); + return this; + } + /** + * @return {SeatControlData} + */ + + + getSeatControlData() { + return this.getObject(SeatControlData, ModuleData.KEY_SEAT_CONTROL_DATA); + } + /** + * @param {AudioControlData} data + * @return {ModuleData} + */ + + + setAudioControlData(data) { + this.validateType(AudioControlData, data); + this.setParameter(ModuleData.KEY_AUDIO_CONTROL_DATA, data); + return this; + } + /** + * @return {AudioControlData} + */ + + + getAudioControlData() { + return this.getObject(AudioControlData, ModuleData.KEY_AUDIO_CONTROL_DATA); + } + /** + * @param {LightControlData} data + * @return {ModuleData} + */ + + + setLightControlData(data) { + this.validateType(LightControlData, data); + this.setParameter(ModuleData.KEY_LIGHT_CONTROL_DATA, data); + return this; + } + /** + * @return {LightControlData} + */ + + + getLightControlData() { + return this.getObject(LightControlData, ModuleData.KEY_LIGHT_CONTROL_DATA); + } + /** + * @param {HMISettingsControlData} data - Corresponds to "HMI_SETTINGS" ModuleType + * @return {ModuleData} + */ + + + setHmiSettingsControlData(data) { + this.validateType(HMISettingsControlData, data); + this.setParameter(ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA, data); + return this; + } + /** + * @return {HMISettingsControlData} + */ + + + getHmiSettingsControlData() { + return this.getObject(HMISettingsControlData, ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA); + } + + } + + ModuleData.KEY_MODULE_TYPE = 'moduleType'; + ModuleData.KEY_MODULE_ID = 'moduleId'; + ModuleData.KEY_RADIO_CONTROL_DATA = 'radioControlData'; + ModuleData.KEY_CLIMATE_CONTROL_DATA = 'climateControlData'; + ModuleData.KEY_SEAT_CONTROL_DATA = 'seatControlData'; + ModuleData.KEY_AUDIO_CONTROL_DATA = 'audioControlData'; + ModuleData.KEY_LIGHT_CONTROL_DATA = 'lightControlData'; + ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA = 'hmiSettingsControlData'; + + /* eslint-disable camelcase */ + + class GetInteriorVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleData); + } + /** + * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which + * data object exists in this struct. For example, if the moduleType is CLIMATE then a + * "climateControlData" should exist + * @return {GetInteriorVehicleDataResponse} + */ + + + setModuleData(data) { + this.validateType(ModuleData, data); + this.setParameter(GetInteriorVehicleDataResponse.KEY_MODULE_DATA, data); + return this; + } + /** + * @return {ModuleData} + */ + + + getModuleData() { + return this.getObject(ModuleData, GetInteriorVehicleDataResponse.KEY_MODULE_DATA); + } + /** + * @param {Boolean} subscribed - It is a conditional-mandatory parameter: must be returned in case "subscribe" + * parameter was present in the related request. if "true" - the "moduleType" from + * request is successfully subscribed and the head unit will send + * onInteriorVehicleData notifications for the moduleType. if "false" - the + * "moduleType" from request is either unsubscribed or failed to subscribe. + * @return {GetInteriorVehicleDataResponse} + */ + + + setIsSubscribed(subscribed) { + this.setParameter(GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED, subscribed); + return this; + } + /** + * @return {Boolean} + */ + + + getIsSubscribed() { + return this.getParameter(GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED); + } + + } + + GetInteriorVehicleDataResponse.KEY_MODULE_DATA = 'moduleData'; + GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED = 'isSubscribed'; + + /* eslint-disable camelcase */ + + class GetInteriorVehicleDataConsent extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleDataConsent); + } + /** + * @param {ModuleType} type - The module type that the app requests to control. + * @return {GetInteriorVehicleDataConsent} + */ + + + setModuleType(type) { + this.validateType(ModuleType, type); + this.setParameter(GetInteriorVehicleDataConsent.KEY_MODULE_TYPE, type); + return this; + } + /** + * @return {ModuleType} + */ + + + getModuleType() { + return this.getObject(ModuleType, GetInteriorVehicleDataConsent.KEY_MODULE_TYPE); + } + /** + * @param {String[]} ids - Ids of a module of same type, published by System Capability. + * @return {GetInteriorVehicleDataConsent} + */ + + + setModuleIds(ids) { + this.setParameter(GetInteriorVehicleDataConsent.KEY_MODULE_IDS, ids); + return this; + } + /** + * @return {String[]} + */ + + + getModuleIds() { + return this.getParameter(GetInteriorVehicleDataConsent.KEY_MODULE_IDS); + } + + } + + GetInteriorVehicleDataConsent.KEY_MODULE_TYPE = 'moduleType'; + GetInteriorVehicleDataConsent.KEY_MODULE_IDS = 'moduleIds'; + + /* eslint-disable camelcase */ + + class GetInteriorVehicleDataConsentResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetInteriorVehicleDataConsent); + } + /** + * @param {Boolean[]} allowed - This array has the same size as "moduleIds" in the request and each element + * corresponds to one moduleId If true, SDL grants the permission for the requested + * module If false, SDL denies the permission for the requested module. + * @return {GetInteriorVehicleDataConsentResponse} + */ + + + setAllowed(allowed) { + this.setParameter(GetInteriorVehicleDataConsentResponse.KEY_ALLOWED, allowed); + return this; + } + /** + * @return {Boolean[]} + */ + + + getAllowed() { + return this.getParameter(GetInteriorVehicleDataConsentResponse.KEY_ALLOWED); + } + + } + + GetInteriorVehicleDataConsentResponse.KEY_ALLOWED = 'allowed'; + + /* eslint-disable camelcase */ + + class ReleaseInteriorVehicleDataModule extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ReleaseInteriorVehicleDataModule); + } + /** + * @param {ModuleType} type + * @return {ReleaseInteriorVehicleDataModule} + */ + + + setModuleType(type) { + this.validateType(ModuleType, type); + this.setParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE, type); + return this; + } + /** + * @return {ModuleType} + */ + + + getModuleType() { + return this.getObject(ModuleType, ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE); + } + /** + * @param {String} id - Id of a module, published by System Capability. + * @return {ReleaseInteriorVehicleDataModule} + */ + + + setModuleId(id) { + this.setParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getModuleId() { + return this.getParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_ID); + } + + } + + ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE = 'moduleType'; + ReleaseInteriorVehicleDataModule.KEY_MODULE_ID = 'moduleId'; + + /* eslint-disable camelcase */ + + class ReleaseInteriorVehicleDataModuleResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.ReleaseInteriorVehicleDataModule); + } + + } + + /* eslint-disable camelcase */ + + class SetInteriorVehicleData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetInteriorVehicleData); + } + /** + * @param {ModuleData} data - The module data to set for the requested RC module. + * @return {SetInteriorVehicleData} + */ + + + setModuleData(data) { + this.validateType(ModuleData, data); + this.setParameter(SetInteriorVehicleData.KEY_MODULE_DATA, data); + return this; + } + /** + * @return {ModuleData} + */ + + + getModuleData() { + return this.getObject(ModuleData, SetInteriorVehicleData.KEY_MODULE_DATA); + } + + } + + SetInteriorVehicleData.KEY_MODULE_DATA = 'moduleData'; + + /* eslint-disable camelcase */ + /** + * Used to set the values of one remote control module + */ + + class SetInteriorVehicleDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetInteriorVehicleData); + } + /** + * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which + * data object exists in this struct. For example, if the moduleType is CLIMATE then a + * "climateControlData" should exist + * @return {SetInteriorVehicleDataResponse} + */ + + + setModuleData(data) { + this.validateType(ModuleData, data); + this.setParameter(SetInteriorVehicleDataResponse.KEY_MODULE_DATA, data); + return this; + } + /** + * @return {ModuleData} + */ + + + getModuleData() { + return this.getObject(ModuleData, SetInteriorVehicleDataResponse.KEY_MODULE_DATA); + } + + } + + SetInteriorVehicleDataResponse.KEY_MODULE_DATA = 'moduleData'; + + /* eslint-disable camelcase */ + /** + * To subscribe in getting changes for Waypoints/destinations + */ + + class SubscribeWayPoints extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SubscribeWayPoints); + } + + } + + /* eslint-disable camelcase */ + + class SubscribeWayPointsResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SubscribeWayPoints); + } + + } + + /* eslint-disable camelcase */ + /** + * Describes what kind of waypoint is requested/provided. + * @typedef {Enum} WayPointType + * @property {Object} _MAP + */ + + class WayPointType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get ALL() { + return WayPointType._MAP.ALL; + } + /** + * @return {String} + */ + + + static get DESTINATION() { + return WayPointType._MAP.DESTINATION; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return WayPointType._valueForKey(key, WayPointType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return WayPointType._keyForValue(value, WayPointType._MAP); + } + + } + + WayPointType._MAP = Object.freeze({ + 'ALL': 'ALL', + 'DESTINATION': 'DESTINATION' + }); + + /* eslint-disable camelcase */ + /** + * Request for getting waypoint/destination data. + */ + + class GetWayPoints extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetWayPoints); + } + /** + * @param {WayPointType} type - To request for either the destination only or for all waypoints including + * destination + * @return {GetWayPoints} + */ + + + setWayPointType(type) { + this.validateType(WayPointType, type); + this.setParameter(GetWayPoints.KEY_WAY_POINT_TYPE, type); + return this; + } + /** + * @return {WayPointType} + */ + + + getWayPointType() { + return this.getObject(WayPointType, GetWayPoints.KEY_WAY_POINT_TYPE); + } + + } + + GetWayPoints.KEY_WAY_POINT_TYPE = 'wayPointType'; + + /* eslint-disable camelcase */ + + class Coordinate extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} degrees - Latitude of the location. + * @return {Coordinate} + */ + + + setLatitudeDegrees(degrees) { + this.setParameter(Coordinate.KEY_LATITUDE_DEGREES, degrees); + return this; + } + /** + * @return {Number} + */ + + + getLatitudeDegrees() { + return this.getParameter(Coordinate.KEY_LATITUDE_DEGREES); + } + /** + * @param {Number} degrees - Longitude of the location. + * @return {Coordinate} + */ + + + setLongitudeDegrees(degrees) { + this.setParameter(Coordinate.KEY_LONGITUDE_DEGREES, degrees); + return this; + } + /** + * @return {Number} + */ + + + getLongitudeDegrees() { + return this.getParameter(Coordinate.KEY_LONGITUDE_DEGREES); + } + + } + + Coordinate.KEY_LATITUDE_DEGREES = 'latitudeDegrees'; + Coordinate.KEY_LONGITUDE_DEGREES = 'longitudeDegrees'; + + /* eslint-disable camelcase */ + + class LocationDetails extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Coordinate} coordinate - Latitude/Longitude of the location. + * @return {LocationDetails} + */ + + + setCoordinate(coordinate) { + this.validateType(Coordinate, coordinate); + this.setParameter(LocationDetails.KEY_COORDINATE, coordinate); + return this; + } + /** + * @return {Coordinate} + */ + + + getCoordinate() { + return this.getObject(Coordinate, LocationDetails.KEY_COORDINATE); + } + /** + * @param {String} name - Name of location. + * @return {LocationDetails} + */ + + + setLocationName(name) { + this.setParameter(LocationDetails.KEY_LOCATION_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getLocationName() { + return this.getParameter(LocationDetails.KEY_LOCATION_NAME); + } + /** + * @param {String[]} lines - Location address for display purposes only + * @return {LocationDetails} + */ + + + setAddressLines(lines) { + this.setParameter(LocationDetails.KEY_ADDRESS_LINES, lines); + return this; + } + /** + * @return {String[]} + */ + + + getAddressLines() { + return this.getParameter(LocationDetails.KEY_ADDRESS_LINES); + } + /** + * @param {String} description - Description intended location / establishment (if applicable) + * @return {LocationDetails} + */ + + + setLocationDescription(description) { + this.setParameter(LocationDetails.KEY_LOCATION_DESCRIPTION, description); + return this; + } + /** + * @return {String} + */ + + + getLocationDescription() { + return this.getParameter(LocationDetails.KEY_LOCATION_DESCRIPTION); + } + /** + * @param {String} number - Phone number of location / establishment. + * @return {LocationDetails} + */ + + + setPhoneNumber(number) { + this.setParameter(LocationDetails.KEY_PHONE_NUMBER, number); + return this; + } + /** + * @return {String} + */ + + + getPhoneNumber() { + return this.getParameter(LocationDetails.KEY_PHONE_NUMBER); + } + /** + * @param {Image} image - Image / icon of intended location. + * @return {LocationDetails} + */ + + + setLocationImage(image) { + this.validateType(Image, image); + this.setParameter(LocationDetails.KEY_LOCATION_IMAGE, image); + return this; + } + /** + * @return {Image} + */ + + + getLocationImage() { + return this.getObject(Image, LocationDetails.KEY_LOCATION_IMAGE); + } + /** + * @param {OASISAddress} address - Address to be used by navigation engines for search + * @return {LocationDetails} + */ + + + setSearchAddress(address) { + this.validateType(OASISAddress, address); + this.setParameter(LocationDetails.KEY_SEARCH_ADDRESS, address); + return this; + } + /** + * @return {OASISAddress} + */ + + + getSearchAddress() { + return this.getObject(OASISAddress, LocationDetails.KEY_SEARCH_ADDRESS); + } + + } + + LocationDetails.KEY_COORDINATE = 'coordinate'; + LocationDetails.KEY_LOCATION_NAME = 'locationName'; + LocationDetails.KEY_ADDRESS_LINES = 'addressLines'; + LocationDetails.KEY_LOCATION_DESCRIPTION = 'locationDescription'; + LocationDetails.KEY_PHONE_NUMBER = 'phoneNumber'; + LocationDetails.KEY_LOCATION_IMAGE = 'locationImage'; + LocationDetails.KEY_SEARCH_ADDRESS = 'searchAddress'; + + /* eslint-disable camelcase */ + + class GetWayPointsResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetWayPoints); + } + /** + * @param {LocationDetails[]} points - See LocationDetails + * @return {GetWayPointsResponse} + */ + + + setWayPoints(points) { + this.validateType(LocationDetails, points, true); + this.setParameter(GetWayPointsResponse.KEY_WAY_POINTS, points); + return this; + } + /** + * @return {LocationDetails[]} + */ + + + getWayPoints() { + return this.getObject(LocationDetails, GetWayPointsResponse.KEY_WAY_POINTS); + } + + } + + GetWayPointsResponse.KEY_WAY_POINTS = 'wayPoints'; + + /* eslint-disable camelcase */ + /** + * Request to unsubscribe from WayPoints and Destination + */ + + class UnsubscribeWayPoints extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeWayPoints); + } + + } + + /* eslint-disable camelcase */ + + class UnsubscribeWayPointsResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnsubscribeWayPoints); + } + /** + * @param {LocationDetails[]} points - See LocationDetails + * @return {UnsubscribeWayPointsResponse} + */ + + + setWayPoints(points) { + this.validateType(LocationDetails, points, true); + this.setParameter(UnsubscribeWayPointsResponse.KEY_WAY_POINTS, points); + return this; + } + /** + * @return {LocationDetails[]} + */ + + + getWayPoints() { + return this.getObject(LocationDetails, UnsubscribeWayPointsResponse.KEY_WAY_POINTS); + } + + } + + UnsubscribeWayPointsResponse.KEY_WAY_POINTS = 'wayPoints'; + + /* eslint-disable camelcase */ + /** + * Enumerations of all available system capability types + * @typedef {Enum} SystemCapabilityType + * @property {Object} _MAP + */ + + class SystemCapabilityType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get NAVIGATION() { + return SystemCapabilityType._MAP.NAVIGATION; + } + /** + * @return {String} + */ + + + static get PHONE_CALL() { + return SystemCapabilityType._MAP.PHONE_CALL; + } + /** + * @return {String} + */ + + + static get VIDEO_STREAMING() { + return SystemCapabilityType._MAP.VIDEO_STREAMING; + } + /** + * @return {String} + */ + + + static get REMOTE_CONTROL() { + return SystemCapabilityType._MAP.REMOTE_CONTROL; + } + /** + * @return {String} + */ + + + static get APP_SERVICES() { + return SystemCapabilityType._MAP.APP_SERVICES; + } + /** + * @return {String} + */ + + + static get SEAT_LOCATION() { + return SystemCapabilityType._MAP.SEAT_LOCATION; + } + /** + * @return {String} + */ + + + static get DISPLAYS() { + return SystemCapabilityType._MAP.DISPLAYS; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return SystemCapabilityType._valueForKey(key, SystemCapabilityType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return SystemCapabilityType._keyForValue(value, SystemCapabilityType._MAP); + } + + } + + SystemCapabilityType._MAP = Object.freeze({ + 'NAVIGATION': 'NAVIGATION', + 'PHONE_CALL': 'PHONE_CALL', + 'VIDEO_STREAMING': 'VIDEO_STREAMING', + 'REMOTE_CONTROL': 'REMOTE_CONTROL', + 'APP_SERVICES': 'APP_SERVICES', + 'SEAT_LOCATION': 'SEAT_LOCATION', + 'DISPLAYS': 'DISPLAYS' + }); + + /* eslint-disable camelcase */ + /** + * Request for expanded information about a supported system/HMI capability + */ + + class GetSystemCapability extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetSystemCapability); + } + /** + * @param {SystemCapabilityType} type - The type of system capability to get more information on + * @return {GetSystemCapability} + */ + + + setSystemCapabilityType(type) { + this.validateType(SystemCapabilityType, type); + this.setParameter(GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE, type); + return this; + } + /** + * @return {SystemCapabilityType} + */ + + + getSystemCapabilityType() { + return this.getObject(SystemCapabilityType, GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE); + } + /** + * @param {Boolean} subscribe - Flag to subscribe to updates of the supplied service capability type. If true, the + * requester will be subscribed. If false, the requester will not be subscribed and be + * removed as a subscriber if it was previously subscribed. + * @return {GetSystemCapability} + */ + + + setSubscribe(subscribe) { + this.setParameter(GetSystemCapability.KEY_SUBSCRIBE, subscribe); + return this; + } + /** + * @return {Boolean} + */ + + + getSubscribe() { + return this.getParameter(GetSystemCapability.KEY_SUBSCRIBE); + } + + } + + GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE = 'systemCapabilityType'; + GetSystemCapability.KEY_SUBSCRIBE = 'subscribe'; + + /* eslint-disable camelcase */ + /** + * Enum for each type of video streaming codec. + * @typedef {Enum} VideoStreamingCodec + * @property {Object} _MAP + */ + + class VideoStreamingCodec extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * A block-oriented motion-compensation-based video compression standard. As of 2014 it is one of the most + * commonly used formats for the recording, compression, and distribution of video content. + * @return {String} + */ + + + static get H264() { + return VideoStreamingCodec._MAP.H264; + } + /** + * High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video compression standard, + * one of several potential successors to the widely used AVC (H.264 or MPEG-4 Part 10). In comparison to AVC, + * HEVC offers about double the data compression ratio at the same level of video quality, or substantially + * improved video quality at the same bit rate. It supports resolutions up to 8192x4320, including 8K UHD. + * @return {String} + */ + + + static get H265() { + return VideoStreamingCodec._MAP.H265; + } + /** + * Theora is derived from the formerly proprietary VP3 codec, released into the public domain by On2 Technologies. + * It is broadly comparable in design and bitrate efficiency to MPEG-4 Part 2, early versions of Windows Media + * Video, and RealVideo while lacking some of the features present in some of these other codecs. It is comparable + * in open standards philosophy to the BBC's Dirac codec. + * @return {String} + */ + + + static get Theora() { + return VideoStreamingCodec._MAP.Theora; + } + /** + * VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and Opus audio. The + * image format WebP is based on VP8's intra-frame coding. VP8's direct successor, VP9, and the emerging royalty- + * free internet video format AV1 from the Alliance for Open Media (AOMedia) are based on VP8. + * @return {String} + */ + + + static get VP8() { + return VideoStreamingCodec._MAP.VP8; + } + /** + * Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video (UHD) and also enables + * lossless compression. + * @return {String} + */ + + + static get VP9() { + return VideoStreamingCodec._MAP.VP9; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VideoStreamingCodec._valueForKey(key, VideoStreamingCodec._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VideoStreamingCodec._keyForValue(value, VideoStreamingCodec._MAP); + } + + } + + VideoStreamingCodec._MAP = Object.freeze({ + 'H264': 'H264', + 'H265': 'H265', + 'Theora': 'Theora', + 'VP8': 'VP8', + 'VP9': 'VP9' + }); + + /* eslint-disable camelcase */ + /** + * Enum for each type of video streaming protocol type. + * @typedef {Enum} VideoStreamingProtocol + * @property {Object} _MAP + */ + + class VideoStreamingProtocol extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Raw stream bytes that contains no timestamp data and is the lowest supported video streaming + * @return {String} + */ + + + static get RAW() { + return VideoStreamingProtocol._MAP.RAW; + } + /** + * RTP facilitates the transfer of real-time data. Information provided by this protocol include timestamps (for + * synchronization), sequence numbers (for packet loss and reordering detection) and the payload format which + * indicates the encoded format of the data. + * @return {String} + */ + + + static get RTP() { + return VideoStreamingProtocol._MAP.RTP; + } + /** + * The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the Real-time Transport + * Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP) for media stream delivery. However, some + * vendors implement proprietary transport protocols. + * @return {String} + */ + + + static get RTSP() { + return VideoStreamingProtocol._MAP.RTSP; + } + /** + * Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by Macromedia for streaming + * audio, video and data over the Internet, between a Flash player and a server. Macromedia is now owned by Adobe, + * which has released an incomplete version of the specification of the protocol for public use. + * @return {String} + */ + + + static get RTMP() { + return VideoStreamingProtocol._MAP.RTMP; + } + /** + * The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and Vorbis audio + * streams. In 2013 it was updated to accommodate VP9 video and Opus audio. + * @return {String} + */ + + + static get WEBM() { + return VideoStreamingProtocol._MAP.WEBM; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VideoStreamingProtocol._valueForKey(key, VideoStreamingProtocol._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VideoStreamingProtocol._keyForValue(value, VideoStreamingProtocol._MAP); + } + + } + + VideoStreamingProtocol._MAP = Object.freeze({ + 'RAW': 'RAW', + 'RTP': 'RTP', + 'RTSP': 'RTSP', + 'RTMP': 'RTMP', + 'WEBM': 'WEBM' + }); + + /* eslint-disable camelcase */ + /** + * Video streaming formats and their specifications. + */ + + class VideoStreamingFormat extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {VideoStreamingProtocol} protocol - Protocol type, see VideoStreamingProtocol + * @return {VideoStreamingFormat} + */ + + + setProtocol(protocol) { + this.validateType(VideoStreamingProtocol, protocol); + this.setParameter(VideoStreamingFormat.KEY_PROTOCOL, protocol); + return this; + } + /** + * @return {VideoStreamingProtocol} + */ + + + getProtocol() { + return this.getObject(VideoStreamingProtocol, VideoStreamingFormat.KEY_PROTOCOL); + } + /** + * @param {VideoStreamingCodec} codec - Codec type, see VideoStreamingCodec + * @return {VideoStreamingFormat} + */ + + + setCodec(codec) { + this.validateType(VideoStreamingCodec, codec); + this.setParameter(VideoStreamingFormat.KEY_CODEC, codec); + return this; + } + /** + * @return {VideoStreamingCodec} + */ + + + getCodec() { + return this.getObject(VideoStreamingCodec, VideoStreamingFormat.KEY_CODEC); } } @@ -25212,6 +42129,9841 @@ VideoStreamingFormat.KEY_PROTOCOL = 'protocol'; VideoStreamingFormat.KEY_CODEC = 'codec'; + /* eslint-disable camelcase */ + /** + * Contains information about this system's video streaming capabilities. + */ + + class VideoStreamingCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {ImageResolution} resolution - The preferred resolution of a video stream for decoding and rendering on + * HMI. + * @return {VideoStreamingCapability} + */ + + + setPreferredResolution(resolution) { + this.validateType(ImageResolution, resolution); + this.setParameter(VideoStreamingCapability.KEY_PREFERRED_RESOLUTION, resolution); + return this; + } + /** + * @return {ImageResolution} + */ + + + getPreferredResolution() { + return this.getObject(ImageResolution, VideoStreamingCapability.KEY_PREFERRED_RESOLUTION); + } + /** + * @param {Number} bitrate - The maximum bitrate of video stream that is supported, in kbps. + * @return {VideoStreamingCapability} + */ + + + setMaxBitrate(bitrate) { + this.setParameter(VideoStreamingCapability.KEY_MAX_BITRATE, bitrate); + return this; + } + /** + * @return {Number} + */ + + + getMaxBitrate() { + return this.getParameter(VideoStreamingCapability.KEY_MAX_BITRATE); + } + /** + * @param {VideoStreamingFormat[]} formats - Detailed information on each format supported by this system, in its + * preferred order (i.e. the first element in the array is most preferable + * to the system). Each object will contain a VideoStreamingFormat that + * describes what can be expected. + * @return {VideoStreamingCapability} + */ + + + setSupportedFormats(formats) { + this.validateType(VideoStreamingFormat, formats, true); + this.setParameter(VideoStreamingCapability.KEY_SUPPORTED_FORMATS, formats); + return this; + } + /** + * @return {VideoStreamingFormat[]} + */ + + + getSupportedFormats() { + return this.getObject(VideoStreamingFormat, VideoStreamingCapability.KEY_SUPPORTED_FORMATS); + } + /** + * @param {Boolean} supported - True if the system can utilize the haptic spatial data from the source being + * streamed. If not included, it can be assumed the module doesn't support haptic + * spatial data'. + * @return {VideoStreamingCapability} + */ + + + setHapticSpatialDataSupported(supported) { + this.setParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED, supported); + return this; + } + /** + * @return {Boolean} + */ + + + getHapticSpatialDataSupported() { + return this.getParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED); + } + /** + * @param {Number} size - The diagonal screen size in inches. + * @return {VideoStreamingCapability} + */ + + + setDiagonalScreenSize(size) { + this.setParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE, size); + return this; + } + /** + * @return {Number} + */ + + + getDiagonalScreenSize() { + return this.getParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE); + } + /** + * @param {Number} inch - PPI is the diagonal resolution in pixels divided by the diagonal screen size in inches. + * @return {VideoStreamingCapability} + */ + + + setPixelPerInch(inch) { + this.setParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH, inch); + return this; + } + /** + * @return {Number} + */ + + + getPixelPerInch() { + return this.getParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH); + } + /** + * @param {Number} scale - The scaling factor the app should use to change the size of the projecting view. + * @return {VideoStreamingCapability} + */ + + + setScale(scale) { + this.setParameter(VideoStreamingCapability.KEY_SCALE, scale); + return this; + } + /** + * @return {Number} + */ + + + getScale() { + return this.getParameter(VideoStreamingCapability.KEY_SCALE); + } + + } + + VideoStreamingCapability.KEY_PREFERRED_RESOLUTION = 'preferredResolution'; + VideoStreamingCapability.KEY_MAX_BITRATE = 'maxBitrate'; + VideoStreamingCapability.KEY_SUPPORTED_FORMATS = 'supportedFormats'; + VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED = 'hapticSpatialDataSupported'; + VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE = 'diagonalScreenSize'; + VideoStreamingCapability.KEY_PIXEL_PER_INCH = 'pixelPerInch'; + VideoStreamingCapability.KEY_SCALE = 'scale'; + + /* eslint-disable camelcase */ + /** + * Extended capabilities of the module's phone feature + */ + + class PhoneCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} enabled - If the module has the ability to perform dial number + * @return {PhoneCapability} + */ + + + setDialNumberEnabled(enabled) { + this.setParameter(PhoneCapability.KEY_DIAL_NUMBER_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getDialNumberEnabled() { + return this.getParameter(PhoneCapability.KEY_DIAL_NUMBER_ENABLED); + } + + } + + PhoneCapability.KEY_DIAL_NUMBER_ENABLED = 'dialNumberEnabled'; + + /* eslint-disable camelcase */ + + class WindowTypeCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {WindowType} type + * @return {WindowTypeCapabilities} + */ + + + setType(type) { + this.validateType(WindowType, type); + this.setParameter(WindowTypeCapabilities.KEY_TYPE, type); + return this; + } + /** + * @return {WindowType} + */ + + + getType() { + return this.getObject(WindowType, WindowTypeCapabilities.KEY_TYPE); + } + /** + * @param {Number} windows + * @return {WindowTypeCapabilities} + */ + + + setMaximumNumberOfWindows(windows) { + this.setParameter(WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS, windows); + return this; + } + /** + * @return {Number} + */ + + + getMaximumNumberOfWindows() { + return this.getParameter(WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS); + } + + } + + WindowTypeCapabilities.KEY_TYPE = 'type'; + WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS = 'maximumNumberOfWindows'; + + /* eslint-disable camelcase */ + + class WindowCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} id - The specified ID of the window. This ID is either one used when sending the CreateWindow + * request, or one of the predefined window ID values from the enum PredefinedWindows. If + * ommited, value is assumed to be the main window on the main display. + * @return {WindowCapability} + */ + + + setWindowID(id) { + this.setParameter(WindowCapability.KEY_WINDOW_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getWindowID() { + return this.getParameter(WindowCapability.KEY_WINDOW_ID); + } + /** + * @param {TextField[]} fields - A set of all fields that support text data. See TextField + * @return {WindowCapability} + */ + + + setTextFields(fields) { + this.validateType(TextField, fields, true); + this.setParameter(WindowCapability.KEY_TEXT_FIELDS, fields); + return this; + } + /** + * @return {TextField[]} + */ + + + getTextFields() { + return this.getObject(TextField, WindowCapability.KEY_TEXT_FIELDS); + } + /** + * @param {ImageField[]} fields - A set of all fields that support images. See ImageField + * @return {WindowCapability} + */ + + + setImageFields(fields) { + this.validateType(ImageField, fields, true); + this.setParameter(WindowCapability.KEY_IMAGE_FIELDS, fields); + return this; + } + /** + * @return {ImageField[]} + */ + + + getImageFields() { + return this.getObject(ImageField, WindowCapability.KEY_IMAGE_FIELDS); + } + /** + * @param {ImageType[]} supported - Provides information about image types supported by the system. + * @return {WindowCapability} + */ + + + setImageTypeSupported(supported) { + this.validateType(ImageType, supported, true); + this.setParameter(WindowCapability.KEY_IMAGE_TYPE_SUPPORTED, supported); + return this; + } + /** + * @return {ImageType[]} + */ + + + getImageTypeSupported() { + return this.getObject(ImageType, WindowCapability.KEY_IMAGE_TYPE_SUPPORTED); + } + /** + * @param {String[]} available - A set of all window templates available on the head unit. + * @return {WindowCapability} + */ + + + setTemplatesAvailable(available) { + this.setParameter(WindowCapability.KEY_TEMPLATES_AVAILABLE, available); + return this; + } + /** + * @return {String[]} + */ + + + getTemplatesAvailable() { + return this.getParameter(WindowCapability.KEY_TEMPLATES_AVAILABLE); + } + /** + * @param {Number} available - The number of on-window custom presets available (if any); otherwise omitted. + * @return {WindowCapability} + */ + + + setNumCustomPresetsAvailable(available) { + this.setParameter(WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, available); + return this; + } + /** + * @return {Number} + */ + + + getNumCustomPresetsAvailable() { + return this.getParameter(WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE); + } + /** + * @param {ButtonCapabilities[]} capabilities - The number of buttons and the capabilities of each on-window button. + * @return {WindowCapability} + */ + + + setButtonCapabilities(capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(WindowCapability.KEY_BUTTON_CAPABILITIES, capabilities); + return this; + } + /** + * @return {ButtonCapabilities[]} + */ + + + getButtonCapabilities() { + return this.getObject(ButtonCapabilities, WindowCapability.KEY_BUTTON_CAPABILITIES); + } + /** + * @param {SoftButtonCapabilities[]} capabilities - The number of soft buttons available on-window and the + * capabilities for each button. + * @return {WindowCapability} + */ + + + setSoftButtonCapabilities(capabilities) { + this.validateType(SoftButtonCapabilities, capabilities, true); + this.setParameter(WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES, capabilities); + return this; + } + /** + * @return {SoftButtonCapabilities[]} + */ + + + getSoftButtonCapabilities() { + return this.getObject(SoftButtonCapabilities, WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES); + } + /** + * @param {MenuLayout[]} available - An array of available menu layouts. If this parameter is not provided, only the + * `LIST` layout is assumed to be available + * @return {WindowCapability} + */ + + + setMenuLayoutsAvailable(available) { + this.validateType(MenuLayout, available, true); + this.setParameter(WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE, available); + return this; + } + /** + * @return {MenuLayout[]} + */ + + + getMenuLayoutsAvailable() { + return this.getObject(MenuLayout, WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE); + } + + } + + WindowCapability.KEY_WINDOW_ID = 'windowID'; + WindowCapability.KEY_TEXT_FIELDS = 'textFields'; + WindowCapability.KEY_IMAGE_FIELDS = 'imageFields'; + WindowCapability.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported'; + WindowCapability.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable'; + WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable'; + WindowCapability.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; + WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities'; + WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE = 'menuLayoutsAvailable'; + + /* eslint-disable camelcase */ + + class DisplayCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name + * @return {DisplayCapability} + */ + + + setDisplayName(name) { + this.setParameter(DisplayCapability.KEY_DISPLAY_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getDisplayName() { + return this.getParameter(DisplayCapability.KEY_DISPLAY_NAME); + } + /** + * @param {WindowTypeCapabilities[]} supported - Informs the application how many windows the app is allowed to + * create per type. + * @return {DisplayCapability} + */ + + + setWindowTypeSupported(supported) { + this.validateType(WindowTypeCapabilities, supported, true); + this.setParameter(DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED, supported); + return this; + } + /** + * @return {WindowTypeCapabilities[]} + */ + + + getWindowTypeSupported() { + return this.getObject(WindowTypeCapabilities, DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED); + } + /** + * @param {WindowCapability[]} capabilities - Contains a list of capabilities of all windows related to the app. + * Once the app has registered the capabilities of all windows are + * provided. GetSystemCapability still allows requesting window + * capabilities of all windows. After registration, only windows with + * capabilities changed will be included. Following cases will cause only + * affected windows to be included: 1. App creates a new window. After + * the window is created, a system capability notification will be sent + * related only to the created window. 2. App sets a new layout to the + * window. The new layout changes window capabilties. The notification + * will reflect those changes to the single window. + * @return {DisplayCapability} + */ + + + setWindowCapabilities(capabilities) { + this.validateType(WindowCapability, capabilities, true); + this.setParameter(DisplayCapability.KEY_WINDOW_CAPABILITIES, capabilities); + return this; + } + /** + * @return {WindowCapability[]} + */ + + + getWindowCapabilities() { + return this.getObject(WindowCapability, DisplayCapability.KEY_WINDOW_CAPABILITIES); + } + + } + + DisplayCapability.KEY_DISPLAY_NAME = 'displayName'; + DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED = 'windowTypeSupported'; + DisplayCapability.KEY_WINDOW_CAPABILITIES = 'windowCapabilities'; + + /* eslint-disable camelcase */ + + class AudioControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - The short friendly name of the light control module. It should not be used to identify a + * module by mobile application. + * @return {AudioControlCapabilities} + */ + + + setModuleName(name) { + this.setParameter(AudioControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getModuleName() { + return this.getParameter(AudioControlCapabilities.KEY_MODULE_NAME); + } + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {AudioControlCapabilities} + */ + + + setModuleInfo(info) { + this.validateType(ModuleInfo, info); + this.setParameter(AudioControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + /** + * @return {ModuleInfo} + */ + + + getModuleInfo() { + return this.getObject(ModuleInfo, AudioControlCapabilities.KEY_MODULE_INFO); + } + /** + * @param {Boolean} available - Availability of the control of audio source. + * @return {AudioControlCapabilities} + */ + + + setSourceAvailable(available) { + this.setParameter(AudioControlCapabilities.KEY_SOURCE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getSourceAvailable() { + return this.getParameter(AudioControlCapabilities.KEY_SOURCE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the keepContext parameter. + * @return {AudioControlCapabilities} + */ + + + setKeepContextAvailable(available) { + this.setParameter(AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getKeepContextAvailable() { + return this.getParameter(AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of audio volume. + * @return {AudioControlCapabilities} + */ + + + setVolumeAvailable(available) { + this.setParameter(AudioControlCapabilities.KEY_VOLUME_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getVolumeAvailable() { + return this.getParameter(AudioControlCapabilities.KEY_VOLUME_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of Equalizer Settings. + * @return {AudioControlCapabilities} + */ + + + setEqualizerAvailable(available) { + this.setParameter(AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getEqualizerAvailable() { + return this.getParameter(AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE); + } + /** + * @param {Number} id - Must be included if equalizerAvailable=true, and assume all IDs starting from 1 to this + * value are valid + * @return {AudioControlCapabilities} + */ + + + setEqualizerMaxChannelId(id) { + this.setParameter(AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getEqualizerMaxChannelId() { + return this.getParameter(AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID); + } + + } + + AudioControlCapabilities.KEY_MODULE_NAME = 'moduleName'; + AudioControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; + AudioControlCapabilities.KEY_SOURCE_AVAILABLE = 'sourceAvailable'; + AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE = 'keepContextAvailable'; + AudioControlCapabilities.KEY_VOLUME_AVAILABLE = 'volumeAvailable'; + AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE = 'equalizerAvailable'; + AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID = 'equalizerMaxChannelId'; + + /* eslint-disable camelcase */ + + class LightCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {LightName} name + * @return {LightCapabilities} + */ + + + setName(name) { + this.validateType(LightName, name); + this.setParameter(LightCapabilities.KEY_NAME, name); + return this; + } + /** + * @return {LightName} + */ + + + getName() { + return this.getObject(LightName, LightCapabilities.KEY_NAME); + } + /** + * @param {Boolean} available - Indicates if the status (ON/OFF) can be set remotely. App shall not use read-only + * values (RAMP_UP/RAMP_DOWN/UNKNOWN/INVALID) in a setInteriorVehicleData request. + * @return {LightCapabilities} + */ + + + setStatusAvailable(available) { + this.setParameter(LightCapabilities.KEY_STATUS_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getStatusAvailable() { + return this.getParameter(LightCapabilities.KEY_STATUS_AVAILABLE); + } + /** + * @param {Boolean} available - Indicates if the light's density can be set remotely (similar to a dimmer). + * @return {LightCapabilities} + */ + + + setDensityAvailable(available) { + this.setParameter(LightCapabilities.KEY_DENSITY_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getDensityAvailable() { + return this.getParameter(LightCapabilities.KEY_DENSITY_AVAILABLE); + } + /** + * @param {Boolean} available - Indicates if the light's color can be set remotely by using the sRGB color space. + * @return {LightCapabilities} + */ + + + setRgbColorSpaceAvailable(available) { + this.setParameter(LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getRgbColorSpaceAvailable() { + return this.getParameter(LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE); + } + + } + + LightCapabilities.KEY_NAME = 'name'; + LightCapabilities.KEY_STATUS_AVAILABLE = 'statusAvailable'; + LightCapabilities.KEY_DENSITY_AVAILABLE = 'densityAvailable'; + LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE = 'rgbColorSpaceAvailable'; + + /* eslint-disable camelcase */ + + class LightControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - The short friendly name of the light control module. It should not be used to identify a + * module by mobile application. + * @return {LightControlCapabilities} + */ + + + setModuleName(name) { + this.setParameter(LightControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getModuleName() { + return this.getParameter(LightControlCapabilities.KEY_MODULE_NAME); + } + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {LightControlCapabilities} + */ + + + setModuleInfo(info) { + this.validateType(ModuleInfo, info); + this.setParameter(LightControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + /** + * @return {ModuleInfo} + */ + + + getModuleInfo() { + return this.getObject(ModuleInfo, LightControlCapabilities.KEY_MODULE_INFO); + } + /** + * @param {LightCapabilities[]} lights - An array of available LightCapabilities that are controllable. + * @return {LightControlCapabilities} + */ + + + setSupportedLights(lights) { + this.validateType(LightCapabilities, lights, true); + this.setParameter(LightControlCapabilities.KEY_SUPPORTED_LIGHTS, lights); + return this; + } + /** + * @return {LightCapabilities[]} + */ + + + getSupportedLights() { + return this.getObject(LightCapabilities, LightControlCapabilities.KEY_SUPPORTED_LIGHTS); + } + + } + + LightControlCapabilities.KEY_MODULE_NAME = 'moduleName'; + LightControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; + LightControlCapabilities.KEY_SUPPORTED_LIGHTS = 'supportedLights'; + + /* eslint-disable camelcase */ + /** + * Contains information about a climate control module's capabilities. + */ + + class ClimateControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - The short friendly name of the climate control module. It should not be used to identify a + * module by mobile application. + * @return {ClimateControlCapabilities} + */ + + + setModuleName(name) { + this.setParameter(ClimateControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getModuleName() { + return this.getParameter(ClimateControlCapabilities.KEY_MODULE_NAME); + } + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {ClimateControlCapabilities} + */ + + + setModuleInfo(info) { + this.validateType(ModuleInfo, info); + this.setParameter(ClimateControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + /** + * @return {ModuleInfo} + */ + + + getModuleInfo() { + return this.getObject(ModuleInfo, ClimateControlCapabilities.KEY_MODULE_INFO); + } + /** + * @param {Boolean} available - Availability of the reading of current temperature. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setCurrentTemperatureAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getCurrentTemperatureAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of fan speed. True: Available, False: Not Available, Not + * present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setFanSpeedAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getFanSpeedAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of desired temperature. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setDesiredTemperatureAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getDesiredTemperatureAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of turn on/off AC. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setAcEnableAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getAcEnableAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of enable/disable air conditioning is ON on the maximum + * level. True: Available, False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setAcMaxEnableAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getAcMaxEnableAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of enable/disable circulate Air mode. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setCirculateAirEnableAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getCirculateAirEnableAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of enable/disable auto mode. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setAutoModeEnableAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getAutoModeEnableAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of enable/disable dual mode. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setDualModeEnableAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getDualModeEnableAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of defrost zones. True: Available, False: Not Available, + * Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setDefrostZoneAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getDefrostZoneAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE); + } + /** + * @param {DefrostZone[]} zone - A set of all defrost zones that are controllable. + * @return {ClimateControlCapabilities} + */ + + + setDefrostZone(zone) { + this.validateType(DefrostZone, zone, true); + this.setParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE, zone); + return this; + } + /** + * @return {DefrostZone[]} + */ + + + getDefrostZone() { + return this.getObject(DefrostZone, ClimateControlCapabilities.KEY_DEFROST_ZONE); + } + /** + * @param {Boolean} available - Availability of the control of air ventilation mode. True: Available, False: Not + * Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setVentilationModeAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getVentilationModeAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE); + } + /** + * @param {VentilationMode[]} mode - A set of all ventilation modes that are controllable. + * @return {ClimateControlCapabilities} + */ + + + setVentilationMode(mode) { + this.validateType(VentilationMode, mode, true); + this.setParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE, mode); + return this; + } + /** + * @return {VentilationMode[]} + */ + + + getVentilationMode() { + return this.getObject(VentilationMode, ClimateControlCapabilities.KEY_VENTILATION_MODE); + } + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Steering Wheel. True: + * Available, False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setHeatedSteeringWheelAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedSteeringWheelAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Windshield. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setHeatedWindshieldAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedWindshieldAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Rear Window. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setHeatedRearWindowAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedRearWindowAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control (enable/disable) of heated Mirrors. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setHeatedMirrorsAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatedMirrorsAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of enable/disable climate control. True: Available, + * False: Not Available, Not present: Not Available. + * @return {ClimateControlCapabilities} + */ + + + setClimateEnableAvailable(available) { + this.setParameter(ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getClimateEnableAvailable() { + return this.getParameter(ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE); + } + + } + + ClimateControlCapabilities.KEY_MODULE_NAME = 'moduleName'; + ClimateControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; + ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE = 'currentTemperatureAvailable'; + ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE = 'fanSpeedAvailable'; + ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE = 'desiredTemperatureAvailable'; + ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE = 'acEnableAvailable'; + ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE = 'acMaxEnableAvailable'; + ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE = 'circulateAirEnableAvailable'; + ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE = 'autoModeEnableAvailable'; + ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE = 'dualModeEnableAvailable'; + ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE = 'defrostZoneAvailable'; + ClimateControlCapabilities.KEY_DEFROST_ZONE = 'defrostZone'; + ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE = 'ventilationModeAvailable'; + ClimateControlCapabilities.KEY_VENTILATION_MODE = 'ventilationMode'; + ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE = 'heatedSteeringWheelAvailable'; + ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE = 'heatedWindshieldAvailable'; + ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE = 'heatedRearWindowAvailable'; + ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE = 'heatedMirrorsAvailable'; + ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE = 'climateEnableAvailable'; + + /* eslint-disable camelcase */ + + class SeatControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - The short friendly name of the light control module. It should not be used to identify a + * module by mobile application. + * @return {SeatControlCapabilities} + */ + + + setModuleName(name) { + this.setParameter(SeatControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getModuleName() { + return this.getParameter(SeatControlCapabilities.KEY_MODULE_NAME); + } + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {SeatControlCapabilities} + */ + + + setModuleInfo(info) { + this.validateType(ModuleInfo, info); + this.setParameter(SeatControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + /** + * @return {ModuleInfo} + */ + + + getModuleInfo() { + return this.getObject(ModuleInfo, SeatControlCapabilities.KEY_MODULE_INFO); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setHeatingEnabledAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatingEnabledAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setCoolingEnabledAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getCoolingEnabledAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setHeatingLevelAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeatingLevelAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setCoolingLevelAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getCoolingLevelAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setHorizontalPositionAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHorizontalPositionAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setVerticalPositionAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getVerticalPositionAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setFrontVerticalPositionAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getFrontVerticalPositionAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setBackVerticalPositionAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getBackVerticalPositionAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setBackTiltAngleAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getBackTiltAngleAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setHeadSupportHorizontalPositionAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeadSupportHorizontalPositionAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setHeadSupportVerticalPositionAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHeadSupportVerticalPositionAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setMassageEnabledAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getMassageEnabledAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setMassageModeAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getMassageModeAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setMassageCushionFirmnessAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getMassageCushionFirmnessAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE); + } + /** + * @param {Boolean} available + * @return {SeatControlCapabilities} + */ + + + setMemoryAvailable(available) { + this.setParameter(SeatControlCapabilities.KEY_MEMORY_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getMemoryAvailable() { + return this.getParameter(SeatControlCapabilities.KEY_MEMORY_AVAILABLE); + } + + } + + SeatControlCapabilities.KEY_MODULE_NAME = 'moduleName'; + SeatControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; + SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE = 'heatingEnabledAvailable'; + SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE = 'coolingEnabledAvailable'; + SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE = 'heatingLevelAvailable'; + SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE = 'coolingLevelAvailable'; + SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE = 'horizontalPositionAvailable'; + SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE = 'verticalPositionAvailable'; + SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE = 'frontVerticalPositionAvailable'; + SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE = 'backVerticalPositionAvailable'; + SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE = 'backTiltAngleAvailable'; + SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE = 'headSupportHorizontalPositionAvailable'; + SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE = 'headSupportVerticalPositionAvailable'; + SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE = 'massageEnabledAvailable'; + SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE = 'massageModeAvailable'; + SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE = 'massageCushionFirmnessAvailable'; + SeatControlCapabilities.KEY_MEMORY_AVAILABLE = 'memoryAvailable'; + + /* eslint-disable camelcase */ + /** + * Contains information about a radio control module's capabilities. + */ + + class RadioControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - The short friendly name of the climate control module. It should not be used to identify a + * module by mobile application. + * @return {RadioControlCapabilities} + */ + + + setModuleName(name) { + this.setParameter(RadioControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getModuleName() { + return this.getParameter(RadioControlCapabilities.KEY_MODULE_NAME); + } + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {RadioControlCapabilities} + */ + + + setModuleInfo(info) { + this.validateType(ModuleInfo, info); + this.setParameter(RadioControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + /** + * @return {ModuleInfo} + */ + + + getModuleInfo() { + return this.getObject(ModuleInfo, RadioControlCapabilities.KEY_MODULE_INFO); + } + /** + * @param {Boolean} available - Availability of the control of enable/disable radio. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setRadioEnableAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getRadioEnableAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of radio band. True: Available, False: Not Available, + * Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setRadioBandAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getRadioBandAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of radio frequency. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setRadioFrequencyAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getRadioFrequencyAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of HD radio channel. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setHdChannelAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHdChannelAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the getting Radio Data System (RDS) data. True: Available, False: + * Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setRdsDataAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getRdsDataAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the getting the number of available HD channels. True: Available, + * False: Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setAvailableHDsAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getAvailableHDsAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the list of available HD sub-channel indexes. True: Available, + * False: Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setAvailableHdChannelsAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getAvailableHdChannelsAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the getting the Radio state. True: Available, False: Not Available, + * Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setStateAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_STATE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getStateAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_STATE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the getting the signal strength. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setSignalStrengthAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getSignalStrengthAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the getting the signal Change Threshold. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setSignalChangeThresholdAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getSignalChangeThresholdAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the getting HD radio Station Information Service (SIS) data. True: + * Available, False: Not Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setSisDataAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getSisDataAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of enable/disable HD radio. True: Available, False: Not + * Available, Not present: Not Available. + * @return {RadioControlCapabilities} + */ + + + setHdRadioEnableAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getHdRadioEnableAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of sirius XM radio. True: Available, False: Not Available, Not present: + * Not Available. + * @return {RadioControlCapabilities} + */ + + + setSiriusxmRadioAvailable(available) { + this.setParameter(RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getSiriusxmRadioAvailable() { + return this.getParameter(RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE); + } + + } + + RadioControlCapabilities.KEY_MODULE_NAME = 'moduleName'; + RadioControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; + RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE = 'radioEnableAvailable'; + RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE = 'radioBandAvailable'; + RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE = 'radioFrequencyAvailable'; + RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE = 'hdChannelAvailable'; + RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE = 'rdsDataAvailable'; + RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE = 'availableHDsAvailable'; + RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE = 'availableHdChannelsAvailable'; + RadioControlCapabilities.KEY_STATE_AVAILABLE = 'stateAvailable'; + RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE = 'signalStrengthAvailable'; + RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE = 'signalChangeThresholdAvailable'; + RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE = 'sisDataAvailable'; + RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE = 'hdRadioEnableAvailable'; + RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE = 'siriusxmRadioAvailable'; + + /* eslint-disable camelcase */ + + class HMISettingsControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - The short friendly name of the hmi setting module. It should not be used to identify a + * module by mobile application. + * @return {HMISettingsControlCapabilities} + */ + + + setModuleName(name) { + this.setParameter(HMISettingsControlCapabilities.KEY_MODULE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getModuleName() { + return this.getParameter(HMISettingsControlCapabilities.KEY_MODULE_NAME); + } + /** + * @param {ModuleInfo} info - Information about a RC module, including its id. + * @return {HMISettingsControlCapabilities} + */ + + + setModuleInfo(info) { + this.validateType(ModuleInfo, info); + this.setParameter(HMISettingsControlCapabilities.KEY_MODULE_INFO, info); + return this; + } + /** + * @return {ModuleInfo} + */ + + + getModuleInfo() { + return this.getObject(ModuleInfo, HMISettingsControlCapabilities.KEY_MODULE_INFO); + } + /** + * @param {Boolean} available - Availability of the control of distance unit. + * @return {HMISettingsControlCapabilities} + */ + + + setDistanceUnitAvailable(available) { + this.setParameter(HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getDistanceUnitAvailable() { + return this.getParameter(HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of temperature unit. + * @return {HMISettingsControlCapabilities} + */ + + + setTemperatureUnitAvailable(available) { + this.setParameter(HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getTemperatureUnitAvailable() { + return this.getParameter(HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE); + } + /** + * @param {Boolean} available - Availability of the control of HMI display mode. + * @return {HMISettingsControlCapabilities} + */ + + + setDisplayModeUnitAvailable(available) { + this.setParameter(HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE, available); + return this; + } + /** + * @return {Boolean} + */ + + + getDisplayModeUnitAvailable() { + return this.getParameter(HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE); + } + + } + + HMISettingsControlCapabilities.KEY_MODULE_NAME = 'moduleName'; + HMISettingsControlCapabilities.KEY_MODULE_INFO = 'moduleInfo'; + HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE = 'distanceUnitAvailable'; + HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE = 'temperatureUnitAvailable'; + HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE = 'displayModeUnitAvailable'; + + /* eslint-disable camelcase */ + + class RemoteControlCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {ClimateControlCapabilities[]} capabilities - If included, the platform supports RC climate controls. For + * this baseline version, maxsize=1. i.e. only one climate + * control module is supported. + * @return {RemoteControlCapabilities} + */ + + + setClimateControlCapabilities(capabilities) { + this.validateType(ClimateControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES, capabilities); + return this; + } + /** + * @return {ClimateControlCapabilities[]} + */ + + + getClimateControlCapabilities() { + return this.getObject(ClimateControlCapabilities, RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES); + } + /** + * @param {RadioControlCapabilities[]} capabilities - If included, the platform supports RC radio controls.For this + * baseline version, maxsize=1. i.e. only one radio control + * module is supported. + * @return {RemoteControlCapabilities} + */ + + + setRadioControlCapabilities(capabilities) { + this.validateType(RadioControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES, capabilities); + return this; + } + /** + * @return {RadioControlCapabilities[]} + */ + + + getRadioControlCapabilities() { + return this.getObject(RadioControlCapabilities, RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES); + } + /** + * @param {ButtonCapabilities[]} capabilities - If included, the platform supports RC button controls with the + * included button names. + * @return {RemoteControlCapabilities} + */ + + + setButtonCapabilities(capabilities) { + this.validateType(ButtonCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES, capabilities); + return this; + } + /** + * @return {ButtonCapabilities[]} + */ + + + getButtonCapabilities() { + return this.getObject(ButtonCapabilities, RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES); + } + /** + * @param {AudioControlCapabilities[]} capabilities - If included, the platform supports audio controls. + * @return {RemoteControlCapabilities} + */ + + + setAudioControlCapabilities(capabilities) { + this.validateType(AudioControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES, capabilities); + return this; + } + /** + * @return {AudioControlCapabilities[]} + */ + + + getAudioControlCapabilities() { + return this.getObject(AudioControlCapabilities, RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES); + } + /** + * @param {HMISettingsControlCapabilities} capabilities - If included, the platform supports hmi setting controls. + * @return {RemoteControlCapabilities} + */ + + + setHmiSettingsControlCapabilities(capabilities) { + this.validateType(HMISettingsControlCapabilities, capabilities); + this.setParameter(RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES, capabilities); + return this; + } + /** + * @return {HMISettingsControlCapabilities} + */ + + + getHmiSettingsControlCapabilities() { + return this.getObject(HMISettingsControlCapabilities, RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES); + } + /** + * @param {LightControlCapabilities} capabilities - If included, the platform supports light controls. + * @return {RemoteControlCapabilities} + */ + + + setLightControlCapabilities(capabilities) { + this.validateType(LightControlCapabilities, capabilities); + this.setParameter(RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES, capabilities); + return this; + } + /** + * @return {LightControlCapabilities} + */ + + + getLightControlCapabilities() { + return this.getObject(LightControlCapabilities, RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES); + } + /** + * @param {SeatControlCapabilities[]} capabilities - If included, the platform supports seat controls. + * @return {RemoteControlCapabilities} + */ + + + setSeatControlCapabilities(capabilities) { + this.validateType(SeatControlCapabilities, capabilities, true); + this.setParameter(RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES, capabilities); + return this; + } + /** + * @return {SeatControlCapabilities[]} + */ + + + getSeatControlCapabilities() { + return this.getObject(SeatControlCapabilities, RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES); + } + + } + + RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES = 'climateControlCapabilities'; + RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES = 'radioControlCapabilities'; + RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities'; + RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES = 'audioControlCapabilities'; + RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES = 'hmiSettingsControlCapabilities'; + RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES = 'lightControlCapabilities'; + RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES = 'seatControlCapabilities'; + + /* eslint-disable camelcase */ + /** + * Contains information about the locations of each seat + */ + + class SeatLocationCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} rows + * @return {SeatLocationCapability} + */ + + + setRows(rows) { + this.setParameter(SeatLocationCapability.KEY_ROWS, rows); + return this; + } + /** + * @return {Number} + */ + + + getRows() { + return this.getParameter(SeatLocationCapability.KEY_ROWS); + } + /** + * @param {Number} columns + * @return {SeatLocationCapability} + */ + + + setColumns(columns) { + this.setParameter(SeatLocationCapability.KEY_COLUMNS, columns); + return this; + } + /** + * @return {Number} + */ + + + getColumns() { + return this.getParameter(SeatLocationCapability.KEY_COLUMNS); + } + /** + * @param {Number} levels + * @return {SeatLocationCapability} + */ + + + setLevels(levels) { + this.setParameter(SeatLocationCapability.KEY_LEVELS, levels); + return this; + } + /** + * @return {Number} + */ + + + getLevels() { + return this.getParameter(SeatLocationCapability.KEY_LEVELS); + } + /** + * @param {SeatLocation[]} seats - Contains a list of SeatLocation in the vehicle + * @return {SeatLocationCapability} + */ + + + setSeats(seats) { + this.validateType(SeatLocation, seats, true); + this.setParameter(SeatLocationCapability.KEY_SEATS, seats); + return this; + } + /** + * @return {SeatLocation[]} + */ + + + getSeats() { + return this.getObject(SeatLocation, SeatLocationCapability.KEY_SEATS); + } + + } + + SeatLocationCapability.KEY_ROWS = 'rows'; + SeatLocationCapability.KEY_COLUMNS = 'columns'; + SeatLocationCapability.KEY_LEVELS = 'levels'; + SeatLocationCapability.KEY_SEATS = 'seats'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} ServiceUpdateReason + * @property {Object} _MAP + */ + + class ServiceUpdateReason extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * The service has just been published with the module and once activated to the primary service of its type, it + * will be ready for possible consumption. + * @return {String} + */ + + + static get PUBLISHED() { + return ServiceUpdateReason._MAP.PUBLISHED; + } + /** + * The service has just been unpublished with the module and is no longer accessible + * @return {String} + */ + + + static get REMOVED() { + return ServiceUpdateReason._MAP.REMOVED; + } + /** + * The service is activated as the primary service of this type. All requests dealing with this service type will + * be handled by this service. + * @return {String} + */ + + + static get ACTIVATED() { + return ServiceUpdateReason._MAP.ACTIVATED; + } + /** + * The service has been deactivated as the primary service of its type + * @return {String} + */ + + + static get DEACTIVATED() { + return ServiceUpdateReason._MAP.DEACTIVATED; + } + /** + * The service has updated its manifest. This could imply updated capabilities + * @return {String} + */ + + + static get MANIFEST_UPDATE() { + return ServiceUpdateReason._MAP.MANIFEST_UPDATE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ServiceUpdateReason._valueForKey(key, ServiceUpdateReason._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ServiceUpdateReason._keyForValue(value, ServiceUpdateReason._MAP); + } + + } + + ServiceUpdateReason._MAP = Object.freeze({ + 'PUBLISHED': 'PUBLISHED', + 'REMOVED': 'REMOVED', + 'ACTIVATED': 'ACTIVATED', + 'DEACTIVATED': 'DEACTIVATED', + 'MANIFEST_UPDATE': 'MANIFEST_UPDATE' + }); + + /* eslint-disable camelcase */ + + class NavigationServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} points - Informs the subscriber if this service can actually accept way points. + * @return {NavigationServiceManifest} + */ + + + setAcceptsWayPoints(points) { + this.setParameter(NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS, points); + return this; + } + /** + * @return {Boolean} + */ + + + getAcceptsWayPoints() { + return this.getParameter(NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS); + } + + } + + NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS = 'acceptsWayPoints'; + + /* eslint-disable camelcase */ + + class WeatherServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} supported + * @return {WeatherServiceManifest} + */ + + + setCurrentForecastSupported(supported) { + this.setParameter(WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED, supported); + return this; + } + /** + * @return {Boolean} + */ + + + getCurrentForecastSupported() { + return this.getParameter(WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED); + } + /** + * @param {Number} amount + * @return {WeatherServiceManifest} + */ + + + setMaxMultidayForecastAmount(amount) { + this.setParameter(WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT, amount); + return this; + } + /** + * @return {Number} + */ + + + getMaxMultidayForecastAmount() { + return this.getParameter(WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT); + } + /** + * @param {Number} amount + * @return {WeatherServiceManifest} + */ + + + setMaxHourlyForecastAmount(amount) { + this.setParameter(WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT, amount); + return this; + } + /** + * @return {Number} + */ + + + getMaxHourlyForecastAmount() { + return this.getParameter(WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT); + } + /** + * @param {Number} amount + * @return {WeatherServiceManifest} + */ + + + setMaxMinutelyForecastAmount(amount) { + this.setParameter(WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT, amount); + return this; + } + /** + * @return {Number} + */ + + + getMaxMinutelyForecastAmount() { + return this.getParameter(WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT); + } + /** + * @param {Boolean} supported + * @return {WeatherServiceManifest} + */ + + + setWeatherForLocationSupported(supported) { + this.setParameter(WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED, supported); + return this; + } + /** + * @return {Boolean} + */ + + + getWeatherForLocationSupported() { + return this.getParameter(WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED); + } + + } + + WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED = 'currentForecastSupported'; + WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT = 'maxMultidayForecastAmount'; + WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT = 'maxHourlyForecastAmount'; + WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT = 'maxMinutelyForecastAmount'; + WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED = 'weatherForLocationSupported'; + + /* eslint-disable camelcase */ + + class MediaServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + + } + + /* eslint-disable camelcase */ + /** + * This manifest contains all the information necessary for the service to be published, activated, and consumers able + * to interact with it + */ + + class AppServiceManifest extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - Unique name of this service + * @return {AppServiceManifest} + */ + + + setServiceName(name) { + this.setParameter(AppServiceManifest.KEY_SERVICE_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getServiceName() { + return this.getParameter(AppServiceManifest.KEY_SERVICE_NAME); + } + /** + * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum + * equivalent types. Parameter is a string to allow for new service types to be used by apps + * on older versions of SDL Core. + * @return {AppServiceManifest} + */ + + + setServiceType(type) { + this.setParameter(AppServiceManifest.KEY_SERVICE_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getServiceType() { + return this.getParameter(AppServiceManifest.KEY_SERVICE_TYPE); + } + /** + * @param {Image} icon - The icon to be associated with this service. Most likely the same as the appIcon. + * @return {AppServiceManifest} + */ + + + setServiceIcon(icon) { + this.validateType(Image, icon); + this.setParameter(AppServiceManifest.KEY_SERVICE_ICON, icon); + return this; + } + /** + * @return {Image} + */ + + + getServiceIcon() { + return this.getObject(Image, AppServiceManifest.KEY_SERVICE_ICON); + } + /** + * @param {Boolean} consumers - If true, app service consumers beyond the IVI system will be able to access this + * service. If false, only the IVI system will be able consume the service. If not + * provided, it is assumed to be false. + * @return {AppServiceManifest} + */ + + + setAllowAppConsumers(consumers) { + this.setParameter(AppServiceManifest.KEY_ALLOW_APP_CONSUMERS, consumers); + return this; + } + /** + * @return {Boolean} + */ + + + getAllowAppConsumers() { + return this.getParameter(AppServiceManifest.KEY_ALLOW_APP_CONSUMERS); + } + /** + * @param {SdlMsgVersion} version - This is the max RPC Spec version the app service understands. This is important + * during the RPC passthrough functionality. If not included, it is assumed the max + * version of the module is acceptable. + * @return {AppServiceManifest} + */ + + + setRpcSpecVersion(version) { + this.validateType(SdlMsgVersion, version); + this.setParameter(AppServiceManifest.KEY_RPC_SPEC_VERSION, version); + return this; + } + /** + * @return {SdlMsgVersion} + */ + + + getRpcSpecVersion() { + return this.getObject(SdlMsgVersion, AppServiceManifest.KEY_RPC_SPEC_VERSION); + } + /** + * @param {Number[]} cs - This field contains the Function IDs for the RPCs that this service intends to handle + * correctly. This means the service will provide meaningful responses. + * @return {AppServiceManifest} + */ + + + setHandledRPCs(cs) { + this.setParameter(AppServiceManifest.KEY_HANDLED_RPCS, cs); + return this; + } + /** + * @return {Number[]} + */ + + + getHandledRPCs() { + return this.getParameter(AppServiceManifest.KEY_HANDLED_RPCS); + } + /** + * @param {MediaServiceManifest} manifest + * @return {AppServiceManifest} + */ + + + setMediaServiceManifest(manifest) { + this.validateType(MediaServiceManifest, manifest); + this.setParameter(AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST, manifest); + return this; + } + /** + * @return {MediaServiceManifest} + */ + + + getMediaServiceManifest() { + return this.getObject(MediaServiceManifest, AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST); + } + /** + * @param {WeatherServiceManifest} manifest + * @return {AppServiceManifest} + */ + + + setWeatherServiceManifest(manifest) { + this.validateType(WeatherServiceManifest, manifest); + this.setParameter(AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST, manifest); + return this; + } + /** + * @return {WeatherServiceManifest} + */ + + + getWeatherServiceManifest() { + return this.getObject(WeatherServiceManifest, AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST); + } + /** + * @param {NavigationServiceManifest} manifest + * @return {AppServiceManifest} + */ + + + setNavigationServiceManifest(manifest) { + this.validateType(NavigationServiceManifest, manifest); + this.setParameter(AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST, manifest); + return this; + } + /** + * @return {NavigationServiceManifest} + */ + + + getNavigationServiceManifest() { + return this.getObject(NavigationServiceManifest, AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST); + } + + } + + AppServiceManifest.KEY_SERVICE_NAME = 'serviceName'; + AppServiceManifest.KEY_SERVICE_TYPE = 'serviceType'; + AppServiceManifest.KEY_SERVICE_ICON = 'serviceIcon'; + AppServiceManifest.KEY_ALLOW_APP_CONSUMERS = 'allowAppConsumers'; + AppServiceManifest.KEY_RPC_SPEC_VERSION = 'rpcSpecVersion'; + AppServiceManifest.KEY_HANDLED_RPCS = 'handledRPCs'; + AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST = 'mediaServiceManifest'; + AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST = 'weatherServiceManifest'; + AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST = 'navigationServiceManifest'; + + /* eslint-disable camelcase */ + /** + * This is the record of an app service publisher that the module has. It should contain the most up to date + * information including the service's active state + */ + + class AppServiceRecord extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} id - A unique ID tied to this specific service record. The ID is supplied by the module that + * services publish themselves. + * @return {AppServiceRecord} + */ + + + setServiceID(id) { + this.setParameter(AppServiceRecord.KEY_SERVICE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getServiceID() { + return this.getParameter(AppServiceRecord.KEY_SERVICE_ID); + } + /** + * @param {AppServiceManifest} manifest - Manifest for the service that this record is for. + * @return {AppServiceRecord} + */ + + + setServiceManifest(manifest) { + this.validateType(AppServiceManifest, manifest); + this.setParameter(AppServiceRecord.KEY_SERVICE_MANIFEST, manifest); + return this; + } + /** + * @return {AppServiceManifest} + */ + + + getServiceManifest() { + return this.getObject(AppServiceManifest, AppServiceRecord.KEY_SERVICE_MANIFEST); + } + /** + * @param {Boolean} published - If true, the service is published and available. If false, the service has likely + * just been unpublished, and should be considered unavailable. + * @return {AppServiceRecord} + */ + + + setServicePublished(published) { + this.setParameter(AppServiceRecord.KEY_SERVICE_PUBLISHED, published); + return this; + } + /** + * @return {Boolean} + */ + + + getServicePublished() { + return this.getParameter(AppServiceRecord.KEY_SERVICE_PUBLISHED); + } + /** + * @param {Boolean} active - If true, the service is the active primary service of the supplied service type. It + * will receive all potential RPCs that are passed through to that service type. If false, + * it is not the primary service of the supplied type. See servicePublished for its + * availability. + * @return {AppServiceRecord} + */ + + + setServiceActive(active) { + this.setParameter(AppServiceRecord.KEY_SERVICE_ACTIVE, active); + return this; + } + /** + * @return {Boolean} + */ + + + getServiceActive() { + return this.getParameter(AppServiceRecord.KEY_SERVICE_ACTIVE); + } + + } + + AppServiceRecord.KEY_SERVICE_ID = 'serviceID'; + AppServiceRecord.KEY_SERVICE_MANIFEST = 'serviceManifest'; + AppServiceRecord.KEY_SERVICE_PUBLISHED = 'servicePublished'; + AppServiceRecord.KEY_SERVICE_ACTIVE = 'serviceActive'; + + /* eslint-disable camelcase */ + + class AppServiceCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {ServiceUpdateReason} reason - Only included in OnSystemCapabilityUpdated. Update reason for service + * record. + * @return {AppServiceCapability} + */ + + + setUpdateReason(reason) { + this.validateType(ServiceUpdateReason, reason); + this.setParameter(AppServiceCapability.KEY_UPDATE_REASON, reason); + return this; + } + /** + * @return {ServiceUpdateReason} + */ + + + getUpdateReason() { + return this.getObject(ServiceUpdateReason, AppServiceCapability.KEY_UPDATE_REASON); + } + /** + * @param {AppServiceRecord} record - Service record for a specific app service provider + * @return {AppServiceCapability} + */ + + + setUpdatedAppServiceRecord(record) { + this.validateType(AppServiceRecord, record); + this.setParameter(AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD, record); + return this; + } + /** + * @return {AppServiceRecord} + */ + + + getUpdatedAppServiceRecord() { + return this.getObject(AppServiceRecord, AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD); + } + + } + + AppServiceCapability.KEY_UPDATE_REASON = 'updateReason'; + AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD = 'updatedAppServiceRecord'; + + /* eslint-disable camelcase */ + /** + * Capabilities of app services including what service types are supported and the current state of services. + */ + + class AppServicesCapabilities extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {AppServiceCapability[]} services - An array of currently available services. If this is an update to the + * capability the affected services will include an update reason in that + * item + * @return {AppServicesCapabilities} + */ + + + setAppServices(services) { + this.validateType(AppServiceCapability, services, true); + this.setParameter(AppServicesCapabilities.KEY_APP_SERVICES, services); + return this; + } + /** + * @return {AppServiceCapability[]} + */ + + + getAppServices() { + return this.getObject(AppServiceCapability, AppServicesCapabilities.KEY_APP_SERVICES); + } + + } + + AppServicesCapabilities.KEY_APP_SERVICES = 'appServices'; + + /* eslint-disable camelcase */ + /** + * Extended capabilities for an onboard navigation system + */ + + class NavigationCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Boolean} enabled - If the module has the ability to add locations to the onboard nav + * @return {NavigationCapability} + */ + + + setSendLocationEnabled(enabled) { + this.setParameter(NavigationCapability.KEY_SEND_LOCATION_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getSendLocationEnabled() { + return this.getParameter(NavigationCapability.KEY_SEND_LOCATION_ENABLED); + } + /** + * @param {Boolean} enabled - If the module has the ability to return way points from onboard nav + * @return {NavigationCapability} + */ + + + setGetWayPointsEnabled(enabled) { + this.setParameter(NavigationCapability.KEY_GET_WAY_POINTS_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getGetWayPointsEnabled() { + return this.getParameter(NavigationCapability.KEY_GET_WAY_POINTS_ENABLED); + } + + } + + NavigationCapability.KEY_SEND_LOCATION_ENABLED = 'sendLocationEnabled'; + NavigationCapability.KEY_GET_WAY_POINTS_ENABLED = 'getWayPointsEnabled'; + + /* eslint-disable camelcase */ + /** + * The systemCapabilityType identifies which data object exists in this struct. For example, if the SystemCapability + * Type is NAVIGATION then a "navigationCapability" should exist + */ + + class SystemCapability extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {SystemCapabilityType} type - Used as a descriptor of what data to expect in this struct. The + * corresponding param to this enum should be included and the only other param + * included. + * @return {SystemCapability} + */ + + + setSystemCapabilityType(type) { + this.validateType(SystemCapabilityType, type); + this.setParameter(SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE, type); + return this; + } + /** + * @return {SystemCapabilityType} + */ + + + getSystemCapabilityType() { + return this.getObject(SystemCapabilityType, SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE); + } + /** + * @param {NavigationCapability} capability - Describes extended capabilities for onboard navigation system + * @return {SystemCapability} + */ + + + setNavigationCapability(capability) { + this.validateType(NavigationCapability, capability); + this.setParameter(SystemCapability.KEY_NAVIGATION_CAPABILITY, capability); + return this; + } + /** + * @return {NavigationCapability} + */ + + + getNavigationCapability() { + return this.getObject(NavigationCapability, SystemCapability.KEY_NAVIGATION_CAPABILITY); + } + /** + * @param {PhoneCapability} capability - Describes extended capabilities of the module's phone feature + * @return {SystemCapability} + */ + + + setPhoneCapability(capability) { + this.validateType(PhoneCapability, capability); + this.setParameter(SystemCapability.KEY_PHONE_CAPABILITY, capability); + return this; + } + /** + * @return {PhoneCapability} + */ + + + getPhoneCapability() { + return this.getObject(PhoneCapability, SystemCapability.KEY_PHONE_CAPABILITY); + } + /** + * @param {VideoStreamingCapability} capability - Describes extended capabilities of the module's phone feature + * @return {SystemCapability} + */ + + + setVideoStreamingCapability(capability) { + this.validateType(VideoStreamingCapability, capability); + this.setParameter(SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY, capability); + return this; + } + /** + * @return {VideoStreamingCapability} + */ + + + getVideoStreamingCapability() { + return this.getObject(VideoStreamingCapability, SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY); + } + /** + * @param {RemoteControlCapabilities} capability - Describes extended capabilities of the module's phone feature + * @return {SystemCapability} + */ + + + setRemoteControlCapability(capability) { + this.validateType(RemoteControlCapabilities, capability); + this.setParameter(SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY, capability); + return this; + } + /** + * @return {RemoteControlCapabilities} + */ + + + getRemoteControlCapability() { + return this.getObject(RemoteControlCapabilities, SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY); + } + /** + * @param {AppServicesCapabilities} capabilities - An array of currently available services. If this is an update to + * the capability the affected services will include an update + * reason in that item + * @return {SystemCapability} + */ + + + setAppServicesCapabilities(capabilities) { + this.validateType(AppServicesCapabilities, capabilities); + this.setParameter(SystemCapability.KEY_APP_SERVICES_CAPABILITIES, capabilities); + return this; + } + /** + * @return {AppServicesCapabilities} + */ + + + getAppServicesCapabilities() { + return this.getObject(AppServicesCapabilities, SystemCapability.KEY_APP_SERVICES_CAPABILITIES); + } + /** + * @param {SeatLocationCapability} capability - Contains information about the locations of each seat + * @return {SystemCapability} + */ + + + setSeatLocationCapability(capability) { + this.validateType(SeatLocationCapability, capability); + this.setParameter(SystemCapability.KEY_SEAT_LOCATION_CAPABILITY, capability); + return this; + } + /** + * @return {SeatLocationCapability} + */ + + + getSeatLocationCapability() { + return this.getObject(SeatLocationCapability, SystemCapability.KEY_SEAT_LOCATION_CAPABILITY); + } + /** + * @param {DisplayCapability[]} capabilities + * @return {SystemCapability} + */ + + + setDisplayCapabilities(capabilities) { + this.validateType(DisplayCapability, capabilities, true); + this.setParameter(SystemCapability.KEY_DISPLAY_CAPABILITIES, capabilities); + return this; + } + /** + * @return {DisplayCapability[]} + */ + + + getDisplayCapabilities() { + return this.getObject(DisplayCapability, SystemCapability.KEY_DISPLAY_CAPABILITIES); + } + + } + + SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE = 'systemCapabilityType'; + SystemCapability.KEY_NAVIGATION_CAPABILITY = 'navigationCapability'; + SystemCapability.KEY_PHONE_CAPABILITY = 'phoneCapability'; + SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY = 'videoStreamingCapability'; + SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY = 'remoteControlCapability'; + SystemCapability.KEY_APP_SERVICES_CAPABILITIES = 'appServicesCapabilities'; + SystemCapability.KEY_SEAT_LOCATION_CAPABILITY = 'seatLocationCapability'; + SystemCapability.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities'; + + /* eslint-disable camelcase */ + + class GetSystemCapabilityResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetSystemCapability); + } + /** + * @param {SystemCapability} capability - The systemCapabilityType identifies which data object exists in this + * struct. For example, if the SystemCapability Type is NAVIGATION then a + * "navigationCapability" should exist + * @return {GetSystemCapabilityResponse} + */ + + + setSystemCapability(capability) { + this.validateType(SystemCapability, capability); + this.setParameter(GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY, capability); + return this; + } + /** + * @return {SystemCapability} + */ + + + getSystemCapability() { + return this.getObject(SystemCapability, GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY); + } + + } + + GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY = 'systemCapability'; + + /* eslint-disable camelcase */ + + class Rectangle extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} x - The upper left X-coordinate of the rectangle + * @return {Rectangle} + */ + + + setX(x) { + this.setParameter(Rectangle.KEY_X, x); + return this; + } + /** + * @return {Number} + */ + + + getX() { + return this.getParameter(Rectangle.KEY_X); + } + /** + * @param {Number} y - The upper left Y-coordinate of the rectangle + * @return {Rectangle} + */ + + + setY(y) { + this.setParameter(Rectangle.KEY_Y, y); + return this; + } + /** + * @return {Number} + */ + + + getY() { + return this.getParameter(Rectangle.KEY_Y); + } + /** + * @param {Number} width - The width of the rectangle + * @return {Rectangle} + */ + + + setWidth(width) { + this.setParameter(Rectangle.KEY_WIDTH, width); + return this; + } + /** + * @return {Number} + */ + + + getWidth() { + return this.getParameter(Rectangle.KEY_WIDTH); + } + /** + * @param {Number} height - The height of the rectangle + * @return {Rectangle} + */ + + + setHeight(height) { + this.setParameter(Rectangle.KEY_HEIGHT, height); + return this; + } + /** + * @return {Number} + */ + + + getHeight() { + return this.getParameter(Rectangle.KEY_HEIGHT); + } + + } + + Rectangle.KEY_X = 'x'; + Rectangle.KEY_Y = 'y'; + Rectangle.KEY_WIDTH = 'width'; + Rectangle.KEY_HEIGHT = 'height'; + + /* eslint-disable camelcase */ + /** + * Defines haptic data for each user control object for video streaming application + */ + + class HapticRect extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} id - A user control spatial identifier + * @return {HapticRect} + */ + + + setId(id) { + this.setParameter(HapticRect.KEY_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getId() { + return this.getParameter(HapticRect.KEY_ID); + } + /** + * @param {Rectangle} rect - The position of the haptic rectangle to be highlighted. The center of this rectangle + * will be "touched" when a press occurs. + * @return {HapticRect} + */ + + + setRect(rect) { + this.validateType(Rectangle, rect); + this.setParameter(HapticRect.KEY_RECT, rect); + return this; + } + /** + * @return {Rectangle} + */ + + + getRect() { + return this.getObject(Rectangle, HapticRect.KEY_RECT); + } + + } + + HapticRect.KEY_ID = 'id'; + HapticRect.KEY_RECT = 'rect'; + + /* eslint-disable camelcase */ + /** + * Send the spatial data gathered from SDLCarWindow or VirtualDisplayEncoder to the HMI. This data will be utilized by + * the HMI to determine how and when haptic events should occur + */ + + class SendHapticData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SendHapticData); + } + /** + * @param {HapticRect[]} data - Array of spatial data structures that represent the locations of all user controls + * present on the HMI. This data should be updated if/when the application presents a + * new screen. When a request is sent, if successful, it will replace all spatial data + * previously sent through RPC. If an empty array is sent, the existing spatial data + * will be cleared + * @return {SendHapticData} + */ + + + setHapticRectData(data) { + this.validateType(HapticRect, data, true); + this.setParameter(SendHapticData.KEY_HAPTIC_RECT_DATA, data); + return this; + } + /** + * @return {HapticRect[]} + */ + + + getHapticRectData() { + return this.getObject(HapticRect, SendHapticData.KEY_HAPTIC_RECT_DATA); + } + + } + + SendHapticData.KEY_HAPTIC_RECT_DATA = 'hapticRectData'; + + /* eslint-disable camelcase */ + + class SendHapticDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SendHapticData); + } + + } + + /* eslint-disable camelcase */ + /** + * Enumeration for the user's preference of which app type to use when both are available + * @typedef {Enum} HybridAppPreference + * @property {Object} _MAP + */ + + class HybridAppPreference extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get MOBILE() { + return HybridAppPreference._MAP.MOBILE; + } + /** + * @return {String} + */ + + + static get CLOUD() { + return HybridAppPreference._MAP.CLOUD; + } + /** + * @return {String} + */ + + + static get BOTH() { + return HybridAppPreference._MAP.BOTH; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return HybridAppPreference._valueForKey(key, HybridAppPreference._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return HybridAppPreference._keyForValue(value, HybridAppPreference._MAP); + } + + } + + HybridAppPreference._MAP = Object.freeze({ + 'MOBILE': 'MOBILE', + 'CLOUD': 'CLOUD', + 'BOTH': 'BOTH' + }); + + /* eslint-disable camelcase */ + + class CloudAppProperties extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String[]} nicknames - An array of app names a cloud app is allowed to register with. If included in a + * SetCloudAppProperties request, this value will overwrite the existing "nicknames" + * field in the app policies section of the policy table. + * @return {CloudAppProperties} + */ + + + setNicknames(nicknames) { + this.setParameter(CloudAppProperties.KEY_NICKNAMES, nicknames); + return this; + } + /** + * @return {String[]} + */ + + + getNicknames() { + return this.getParameter(CloudAppProperties.KEY_NICKNAMES); + } + /** + * @param {String} id + * @return {CloudAppProperties} + */ + + + setAppID(id) { + this.setParameter(CloudAppProperties.KEY_APP_ID, id); + return this; + } + /** + * @return {String} + */ + + + getAppID() { + return this.getParameter(CloudAppProperties.KEY_APP_ID); + } + /** + * @param {Boolean} enabled - If true, cloud app will be included in HMI RPC UpdateAppList + * @return {CloudAppProperties} + */ + + + setEnabled(enabled) { + this.setParameter(CloudAppProperties.KEY_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getEnabled() { + return this.getParameter(CloudAppProperties.KEY_ENABLED); + } + /** + * @param {String} token - Used to authenticate websocket connection on app activation + * @return {CloudAppProperties} + */ + + + setAuthToken(token) { + this.setParameter(CloudAppProperties.KEY_AUTH_TOKEN, token); + return this; + } + /** + * @return {String} + */ + + + getAuthToken() { + return this.getParameter(CloudAppProperties.KEY_AUTH_TOKEN); + } + /** + * @param {String} type - Specifies the connection type Core should use + * @return {CloudAppProperties} + */ + + + setCloudTransportType(type) { + this.setParameter(CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getCloudTransportType() { + return this.getParameter(CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE); + } + /** + * @param {HybridAppPreference} preference - Specifies the user preference to use the cloud app version or mobile + * app version when both are available + * @return {CloudAppProperties} + */ + + + setHybridAppPreference(preference) { + this.validateType(HybridAppPreference, preference); + this.setParameter(CloudAppProperties.KEY_HYBRID_APP_PREFERENCE, preference); + return this; + } + /** + * @return {HybridAppPreference} + */ + + + getHybridAppPreference() { + return this.getObject(HybridAppPreference, CloudAppProperties.KEY_HYBRID_APP_PREFERENCE); + } + /** + * @param {String} endpoint - Specifies the endpoint which Core will attempt to connect to when this app is selected + * @return {CloudAppProperties} + */ + + + setEndpoint(endpoint) { + this.setParameter(CloudAppProperties.KEY_ENDPOINT, endpoint); + return this; + } + /** + * @return {String} + */ + + + getEndpoint() { + return this.getParameter(CloudAppProperties.KEY_ENDPOINT); + } + + } + + CloudAppProperties.KEY_NICKNAMES = 'nicknames'; + CloudAppProperties.KEY_APP_ID = 'appID'; + CloudAppProperties.KEY_ENABLED = 'enabled'; + CloudAppProperties.KEY_AUTH_TOKEN = 'authToken'; + CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE = 'cloudTransportType'; + CloudAppProperties.KEY_HYBRID_APP_PREFERENCE = 'hybridAppPreference'; + CloudAppProperties.KEY_ENDPOINT = 'endpoint'; + + /* eslint-disable camelcase */ + /** + * RPC used to enable/disable a cloud application and set its cloud-related policy properties + */ + + class SetCloudAppProperties extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetCloudAppProperties); + } + /** + * @param {CloudAppProperties} properties - The new cloud application properties + * @return {SetCloudAppProperties} + */ + + + setProperties(properties) { + this.validateType(CloudAppProperties, properties); + this.setParameter(SetCloudAppProperties.KEY_PROPERTIES, properties); + return this; + } + /** + * @return {CloudAppProperties} + */ + + + getProperties() { + return this.getObject(CloudAppProperties, SetCloudAppProperties.KEY_PROPERTIES); + } + + } + + SetCloudAppProperties.KEY_PROPERTIES = 'properties'; + + /* eslint-disable camelcase */ + /** + * The response to SetCloudAppProperties + */ + + class SetCloudAppPropertiesResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.SetCloudAppProperties); + } + + } + + /* eslint-disable camelcase */ + /** + * RPC used to get the current properties of a cloud application + */ + + class GetCloudAppProperties extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetCloudAppProperties); + } + /** + * @param {String} id + * @return {GetCloudAppProperties} + */ + + + setAppID(id) { + this.setParameter(GetCloudAppProperties.KEY_APP_ID, id); + return this; + } + /** + * @return {String} + */ + + + getAppID() { + return this.getParameter(GetCloudAppProperties.KEY_APP_ID); + } + + } + + GetCloudAppProperties.KEY_APP_ID = 'appID'; + + /* eslint-disable camelcase */ + /** + * The response to GetCloudAppProperties + */ + + class GetCloudAppPropertiesResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetCloudAppProperties); + } + /** + * @param {CloudAppProperties} properties - The requested cloud application properties + * @return {GetCloudAppPropertiesResponse} + */ + + + setProperties(properties) { + this.validateType(CloudAppProperties, properties); + this.setParameter(GetCloudAppPropertiesResponse.KEY_PROPERTIES, properties); + return this; + } + /** + * @return {CloudAppProperties} + */ + + + getProperties() { + return this.getObject(CloudAppProperties, GetCloudAppPropertiesResponse.KEY_PROPERTIES); + } + + } + + GetCloudAppPropertiesResponse.KEY_PROPERTIES = 'properties'; + + /* eslint-disable camelcase */ + /** + * Registers a service offered by this app on the module. Subsequent calls with the same service type will update the + * manifest for that service. + */ + + class PublishAppService extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PublishAppService); + } + /** + * @param {AppServiceManifest} manifest - The manifest of the service that wishes to be published. If already + * published, the updated manifest for this service. + * @return {PublishAppService} + */ + + + setAppServiceManifest(manifest) { + this.validateType(AppServiceManifest, manifest); + this.setParameter(PublishAppService.KEY_APP_SERVICE_MANIFEST, manifest); + return this; + } + /** + * @return {AppServiceManifest} + */ + + + getAppServiceManifest() { + return this.getObject(AppServiceManifest, PublishAppService.KEY_APP_SERVICE_MANIFEST); + } + + } + + PublishAppService.KEY_APP_SERVICE_MANIFEST = 'appServiceManifest'; + + /* eslint-disable camelcase */ + /** + * Response to the request to register a service offered by this app on the module + */ + + class PublishAppServiceResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PublishAppService); + } + /** + * @param {AppServiceRecord} record - If the request was successful, this object will be the current status of the + * service record for the published service. This will include the Core supplied + * service ID. + * @return {PublishAppServiceResponse} + */ + + + setAppServiceRecord(record) { + this.validateType(AppServiceRecord, record); + this.setParameter(PublishAppServiceResponse.KEY_APP_SERVICE_RECORD, record); + return this; + } + /** + * @return {AppServiceRecord} + */ + + + getAppServiceRecord() { + return this.getObject(AppServiceRecord, PublishAppServiceResponse.KEY_APP_SERVICE_RECORD); + } + + } + + PublishAppServiceResponse.KEY_APP_SERVICE_RECORD = 'appServiceRecord'; + + /* eslint-disable camelcase */ + /** + * Unpublish an existing service published by this application. + */ + + class UnpublishAppService extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnpublishAppService); + } + /** + * @param {String} id - The ID of the service to be unpublished. + * @return {UnpublishAppService} + */ + + + setServiceID(id) { + this.setParameter(UnpublishAppService.KEY_SERVICE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getServiceID() { + return this.getParameter(UnpublishAppService.KEY_SERVICE_ID); + } + + } + + UnpublishAppService.KEY_SERVICE_ID = 'serviceID'; + + /* eslint-disable camelcase */ + /** + * The response to UnpublishAppService + */ + + class UnpublishAppServiceResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.UnpublishAppService); + } + + } + + /* eslint-disable camelcase */ + /** + * This request asks the module for current data related to the specific service. It also includes an option to + * subscribe to that service for future updates + */ + + class GetAppServiceData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetAppServiceData); + } + /** + * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum + * equivalent types. Parameter is a string to allow for new service types to be used by apps + * on older versions of SDL Core. + * @return {GetAppServiceData} + */ + + + setServiceType(type) { + this.setParameter(GetAppServiceData.KEY_SERVICE_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getServiceType() { + return this.getParameter(GetAppServiceData.KEY_SERVICE_TYPE); + } + /** + * @param {Boolean} subscribe - If true, the consumer is requesting to subscribe to all future updates from the + * service publisher. If false, the consumer doesn't wish to subscribe and should be + * unsubscribed if it was previously subscribed. + * @return {GetAppServiceData} + */ + + + setSubscribe(subscribe) { + this.setParameter(GetAppServiceData.KEY_SUBSCRIBE, subscribe); + return this; + } + /** + * @return {Boolean} + */ + + + getSubscribe() { + return this.getParameter(GetAppServiceData.KEY_SUBSCRIBE); + } + + } + + GetAppServiceData.KEY_SERVICE_TYPE = 'serviceType'; + GetAppServiceData.KEY_SUBSCRIBE = 'subscribe'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} NavigationJunction + * @property {Object} _MAP + */ + + class NavigationJunction extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * A junction that represents a standard intersection with a single road crossing another. + * @return {String} + */ + + + static get REGULAR() { + return NavigationJunction._MAP.REGULAR; + } + /** + * A junction where the road splits off into two paths; a fork in the road. + * @return {String} + */ + + + static get BIFURCATION() { + return NavigationJunction._MAP.BIFURCATION; + } + /** + * A junction that has multiple intersections and paths. + * @return {String} + */ + + + static get MULTI_CARRIAGEWAY() { + return NavigationJunction._MAP.MULTI_CARRIAGEWAY; + } + /** + * A junction where traffic moves in a single direction around a central, non-traversable point to reach one of + * the connecting roads. + * @return {String} + */ + + + static get ROUNDABOUT() { + return NavigationJunction._MAP.ROUNDABOUT; + } + /** + * Similar to a roundabout, however the center of the roundabout is fully traversable. Also known as a mini- + * roundabout. + * @return {String} + */ + + + static get TRAVERSABLE_ROUNDABOUT() { + return NavigationJunction._MAP.TRAVERSABLE_ROUNDABOUT; + } + /** + * A junction where lefts diverge to the right, then curve to the left, converting a left turn to a crossing + * maneuver. + * @return {String} + */ + + + static get JUGHANDLE() { + return NavigationJunction._MAP.JUGHANDLE; + } + /** + * Multiple way intersection that allows traffic to flow based on priority; most commonly right of way and first + * in, first out. + * @return {String} + */ + + + static get ALL_WAY_YIELD() { + return NavigationJunction._MAP.ALL_WAY_YIELD; + } + /** + * A junction designated for traffic turn arounds. + * @return {String} + */ + + + static get TURN_AROUND() { + return NavigationJunction._MAP.TURN_AROUND; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return NavigationJunction._valueForKey(key, NavigationJunction._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return NavigationJunction._keyForValue(value, NavigationJunction._MAP); + } + + } + + NavigationJunction._MAP = Object.freeze({ + 'REGULAR': 'REGULAR', + 'BIFURCATION': 'BIFURCATION', + 'MULTI_CARRIAGEWAY': 'MULTI_CARRIAGEWAY', + 'ROUNDABOUT': 'ROUNDABOUT', + 'TRAVERSABLE_ROUNDABOUT': 'TRAVERSABLE_ROUNDABOUT', + 'JUGHANDLE': 'JUGHANDLE', + 'ALL_WAY_YIELD': 'ALL_WAY_YIELD', + 'TURN_AROUND': 'TURN_AROUND' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} Direction + * @property {Object} _MAP + */ + + class Direction extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get LEFT() { + return Direction._MAP.LEFT; + } + /** + * @return {String} + */ + + + static get RIGHT() { + return Direction._MAP.RIGHT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return Direction._valueForKey(key, Direction._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return Direction._keyForValue(value, Direction._MAP); + } + + } + + Direction._MAP = Object.freeze({ + 'LEFT': 'LEFT', + 'RIGHT': 'RIGHT' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} NavigationAction + * @property {Object} _MAP + */ + + class NavigationAction extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Using this action plus a supplied direction can give the type of turn. + * @return {String} + */ + + + static get TURN() { + return NavigationAction._MAP.TURN; + } + /** + * @return {String} + */ + + + static get EXIT() { + return NavigationAction._MAP.EXIT; + } + /** + * @return {String} + */ + + + static get STAY() { + return NavigationAction._MAP.STAY; + } + /** + * @return {String} + */ + + + static get MERGE() { + return NavigationAction._MAP.MERGE; + } + /** + * @return {String} + */ + + + static get FERRY() { + return NavigationAction._MAP.FERRY; + } + /** + * @return {String} + */ + + + static get CAR_SHUTTLE_TRAIN() { + return NavigationAction._MAP.CAR_SHUTTLE_TRAIN; + } + /** + * @return {String} + */ + + + static get WAYPOINT() { + return NavigationAction._MAP.WAYPOINT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return NavigationAction._valueForKey(key, NavigationAction._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return NavigationAction._keyForValue(value, NavigationAction._MAP); + } + + } + + NavigationAction._MAP = Object.freeze({ + 'TURN': 'TURN', + 'EXIT': 'EXIT', + 'STAY': 'STAY', + 'MERGE': 'MERGE', + 'FERRY': 'FERRY', + 'CAR_SHUTTLE_TRAIN': 'CAR_SHUTTLE_TRAIN', + 'WAYPOINT': 'WAYPOINT' + }); + + /* eslint-disable camelcase */ + + class NavigationInstruction extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {LocationDetails} details + * @return {NavigationInstruction} + */ + + + setLocationDetails(details) { + this.validateType(LocationDetails, details); + this.setParameter(NavigationInstruction.KEY_LOCATION_DETAILS, details); + return this; + } + /** + * @return {LocationDetails} + */ + + + getLocationDetails() { + return this.getObject(LocationDetails, NavigationInstruction.KEY_LOCATION_DETAILS); + } + /** + * @param {NavigationAction} action + * @return {NavigationInstruction} + */ + + + setAction(action) { + this.validateType(NavigationAction, action); + this.setParameter(NavigationInstruction.KEY_ACTION, action); + return this; + } + /** + * @return {NavigationAction} + */ + + + getAction() { + return this.getObject(NavigationAction, NavigationInstruction.KEY_ACTION); + } + /** + * @param {DateTime} eta + * @return {NavigationInstruction} + */ + + + setEta(eta) { + this.validateType(DateTime, eta); + this.setParameter(NavigationInstruction.KEY_ETA, eta); + return this; + } + /** + * @return {DateTime} + */ + + + getEta() { + return this.getObject(DateTime, NavigationInstruction.KEY_ETA); + } + /** + * @param {Number} bearing - The angle at which this instruction takes place. For example, 0 would mean straight, + * less than 45 is bearing right, greater than 135 is sharp right, between 45 and 135 is a + * regular right, and 180 is a U-Turn, etc. + * @return {NavigationInstruction} + */ + + + setBearing(bearing) { + this.setParameter(NavigationInstruction.KEY_BEARING, bearing); + return this; + } + /** + * @return {Number} + */ + + + getBearing() { + return this.getParameter(NavigationInstruction.KEY_BEARING); + } + /** + * @param {NavigationJunction} type + * @return {NavigationInstruction} + */ + + + setJunctionType(type) { + this.validateType(NavigationJunction, type); + this.setParameter(NavigationInstruction.KEY_JUNCTION_TYPE, type); + return this; + } + /** + * @return {NavigationJunction} + */ + + + getJunctionType() { + return this.getObject(NavigationJunction, NavigationInstruction.KEY_JUNCTION_TYPE); + } + /** + * @param {Direction} side - Used to infer which side of the road this instruction takes place. For a U-Turn + * (action=TURN, bearing=180) this will determine which direction the turn should take + * place. + * @return {NavigationInstruction} + */ + + + setDrivingSide(side) { + this.validateType(Direction, side); + this.setParameter(NavigationInstruction.KEY_DRIVING_SIDE, side); + return this; + } + /** + * @return {Direction} + */ + + + getDrivingSide() { + return this.getObject(Direction, NavigationInstruction.KEY_DRIVING_SIDE); + } + /** + * @param {String} details - This is a string representation of this instruction, used to display instructions to + * the users. This is not intended to be read aloud to the users, see the param prompt in + * NavigationServiceData for that. + * @return {NavigationInstruction} + */ + + + setDetails(details) { + this.setParameter(NavigationInstruction.KEY_DETAILS, details); + return this; + } + /** + * @return {String} + */ + + + getDetails() { + return this.getParameter(NavigationInstruction.KEY_DETAILS); + } + /** + * @param {Image} image - An image representation of this instruction. + * @return {NavigationInstruction} + */ + + + setImage(image) { + this.validateType(Image, image); + this.setParameter(NavigationInstruction.KEY_IMAGE, image); + return this; + } + /** + * @return {Image} + */ + + + getImage() { + return this.getObject(Image, NavigationInstruction.KEY_IMAGE); + } + + } + + NavigationInstruction.KEY_LOCATION_DETAILS = 'locationDetails'; + NavigationInstruction.KEY_ACTION = 'action'; + NavigationInstruction.KEY_ETA = 'eta'; + NavigationInstruction.KEY_BEARING = 'bearing'; + NavigationInstruction.KEY_JUNCTION_TYPE = 'junctionType'; + NavigationInstruction.KEY_DRIVING_SIDE = 'drivingSide'; + NavigationInstruction.KEY_DETAILS = 'details'; + NavigationInstruction.KEY_IMAGE = 'image'; + + /* eslint-disable camelcase */ + /** + * This data is related to what a navigation service would provide. + */ + + class NavigationServiceData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {DateTime} stamp - This is the timestamp of when the data was generated. This is to ensure any time or + * distance given in the data can accurately be adjusted if necessary. + * @return {NavigationServiceData} + */ + + + setTimeStamp(stamp) { + this.validateType(DateTime, stamp); + this.setParameter(NavigationServiceData.KEY_TIME_STAMP, stamp); + return this; + } + /** + * @return {DateTime} + */ + + + getTimeStamp() { + return this.getObject(DateTime, NavigationServiceData.KEY_TIME_STAMP); + } + /** + * @param {LocationDetails} origin + * @return {NavigationServiceData} + */ + + + setOrigin(origin) { + this.validateType(LocationDetails, origin); + this.setParameter(NavigationServiceData.KEY_ORIGIN, origin); + return this; + } + /** + * @return {LocationDetails} + */ + + + getOrigin() { + return this.getObject(LocationDetails, NavigationServiceData.KEY_ORIGIN); + } + /** + * @param {LocationDetails} destination + * @return {NavigationServiceData} + */ + + + setDestination(destination) { + this.validateType(LocationDetails, destination); + this.setParameter(NavigationServiceData.KEY_DESTINATION, destination); + return this; + } + /** + * @return {LocationDetails} + */ + + + getDestination() { + return this.getObject(LocationDetails, NavigationServiceData.KEY_DESTINATION); + } + /** + * @param {DateTime} eta + * @return {NavigationServiceData} + */ + + + setDestinationETA(eta) { + this.validateType(DateTime, eta); + this.setParameter(NavigationServiceData.KEY_DESTINATION_ETA, eta); + return this; + } + /** + * @return {DateTime} + */ + + + getDestinationETA() { + return this.getObject(DateTime, NavigationServiceData.KEY_DESTINATION_ETA); + } + /** + * @param {NavigationInstruction[]} instructions - This array should be ordered with all remaining instructions. The + * start of this array should always contain the next instruction. + * @return {NavigationServiceData} + */ + + + setInstructions(instructions) { + this.validateType(NavigationInstruction, instructions, true); + this.setParameter(NavigationServiceData.KEY_INSTRUCTIONS, instructions); + return this; + } + /** + * @return {NavigationInstruction[]} + */ + + + getInstructions() { + return this.getObject(NavigationInstruction, NavigationServiceData.KEY_INSTRUCTIONS); + } + /** + * @param {DateTime} eta + * @return {NavigationServiceData} + */ + + + setNextInstructionETA(eta) { + this.validateType(DateTime, eta); + this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA, eta); + return this; + } + /** + * @return {DateTime} + */ + + + getNextInstructionETA() { + return this.getObject(DateTime, NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA); + } + /** + * @param {Number} distance - The distance to this instruction from current location. This should only be updated + * ever .1 unit of distance. For more accuracy the consumer can use the GPS location of + * itself and the next instruction. + * @return {NavigationServiceData} + */ + + + setNextInstructionDistance(distance) { + this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE, distance); + return this; + } + /** + * @return {Number} + */ + + + getNextInstructionDistance() { + return this.getParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE); + } + /** + * @param {Number} scale - Distance till next maneuver (starting from) from previous maneuver. + * @return {NavigationServiceData} + */ + + + setNextInstructionDistanceScale(scale) { + this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE, scale); + return this; + } + /** + * @return {Number} + */ + + + getNextInstructionDistanceScale() { + return this.getParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE); + } + /** + * @param {String} prompt - This is a prompt message that should be conveyed to the user through either display or + * voice (TTS). This param will change often as it should represent the following: + * approaching instruction, post instruction, alerts that affect the current navigation + * session, etc. + * @return {NavigationServiceData} + */ + + + setPrompt(prompt) { + this.setParameter(NavigationServiceData.KEY_PROMPT, prompt); + return this; + } + /** + * @return {String} + */ + + + getPrompt() { + return this.getParameter(NavigationServiceData.KEY_PROMPT); + } + + } + + NavigationServiceData.KEY_TIME_STAMP = 'timeStamp'; + NavigationServiceData.KEY_ORIGIN = 'origin'; + NavigationServiceData.KEY_DESTINATION = 'destination'; + NavigationServiceData.KEY_DESTINATION_ETA = 'destinationETA'; + NavigationServiceData.KEY_INSTRUCTIONS = 'instructions'; + NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA = 'nextInstructionETA'; + NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE = 'nextInstructionDistance'; + NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE = 'nextInstructionDistanceScale'; + NavigationServiceData.KEY_PROMPT = 'prompt'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} MediaType + * @property {Object} _MAP + */ + + class MediaType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get MUSIC() { + return MediaType._MAP.MUSIC; + } + /** + * @return {String} + */ + + + static get PODCAST() { + return MediaType._MAP.PODCAST; + } + /** + * @return {String} + */ + + + static get AUDIOBOOK() { + return MediaType._MAP.AUDIOBOOK; + } + /** + * @return {String} + */ + + + static get OTHER() { + return MediaType._MAP.OTHER; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return MediaType._valueForKey(key, MediaType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return MediaType._keyForValue(value, MediaType._MAP); + } + + } + + MediaType._MAP = Object.freeze({ + 'MUSIC': 'MUSIC', + 'PODCAST': 'PODCAST', + 'AUDIOBOOK': 'AUDIOBOOK', + 'OTHER': 'OTHER' + }); + + /* eslint-disable camelcase */ + /** + * This data is related to what a media service should provide + */ + + class MediaServiceData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {MediaType} type - The type of the currently playing or paused track. + * @return {MediaServiceData} + */ + + + setMediaType(type) { + this.validateType(MediaType, type); + this.setParameter(MediaServiceData.KEY_MEDIA_TYPE, type); + return this; + } + /** + * @return {MediaType} + */ + + + getMediaType() { + return this.getObject(MediaType, MediaServiceData.KEY_MEDIA_TYPE); + } + /** + * @param {String} title - Music: The name of the current track Podcast: The name of the current episode Audiobook: + * The name of the current chapter + * @return {MediaServiceData} + */ + + + setMediaTitle(title) { + this.setParameter(MediaServiceData.KEY_MEDIA_TITLE, title); + return this; + } + /** + * @return {String} + */ + + + getMediaTitle() { + return this.getParameter(MediaServiceData.KEY_MEDIA_TITLE); + } + /** + * @param {String} artist - Music: The name of the current album artist Podcast: The provider of the podcast (hosts, + * network, company) Audiobook: The book author's name + * @return {MediaServiceData} + */ + + + setMediaArtist(artist) { + this.setParameter(MediaServiceData.KEY_MEDIA_ARTIST, artist); + return this; + } + /** + * @return {String} + */ + + + getMediaArtist() { + return this.getParameter(MediaServiceData.KEY_MEDIA_ARTIST); + } + /** + * @param {String} album - Music: The name of the current album Podcast: The name of the current podcast show + * Audiobook: The name of the current book + * @return {MediaServiceData} + */ + + + setMediaAlbum(album) { + this.setParameter(MediaServiceData.KEY_MEDIA_ALBUM, album); + return this; + } + /** + * @return {String} + */ + + + getMediaAlbum() { + return this.getParameter(MediaServiceData.KEY_MEDIA_ALBUM); + } + /** + * @param {String} name - Music: The name of the playlist or radio station, if the user is playing from a playlist, + * otherwise, Null Podcast: The name of the playlist, if the user is playing from a playlist, + * otherwise, Null Audiobook: Likely not applicable, possibly a collection or "playlist" of + * books + * @return {MediaServiceData} + */ + + + setPlaylistName(name) { + this.setParameter(MediaServiceData.KEY_PLAYLIST_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getPlaylistName() { + return this.getParameter(MediaServiceData.KEY_PLAYLIST_NAME); + } + /** + * @param {Boolean} explicit - Whether or not the content currently playing (e.g. the track, episode, or book) + * contains explicit content + * @return {MediaServiceData} + */ + + + setIsExplicit(explicit) { + this.setParameter(MediaServiceData.KEY_IS_EXPLICIT, explicit); + return this; + } + /** + * @return {Boolean} + */ + + + getIsExplicit() { + return this.getParameter(MediaServiceData.KEY_IS_EXPLICIT); + } + /** + * @param {Number} progress - Music: The current progress of the track in seconds Podcast: The current progress of + * the episode in seconds Audiobook: The current progress of the current segment (e.g. + * the chapter) in seconds + * @return {MediaServiceData} + */ + + + setTrackPlaybackProgress(progress) { + this.setParameter(MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS, progress); + return this; + } + /** + * @return {Number} + */ + + + getTrackPlaybackProgress() { + return this.getParameter(MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS); + } + /** + * @param {Number} duration - Music: The total duration of the track in seconds Podcast: The total duration of the + * episode in seconds Audiobook: The total duration of the current segment (e.g. the + * chapter) in seconds + * @return {MediaServiceData} + */ + + + setTrackPlaybackDuration(duration) { + this.setParameter(MediaServiceData.KEY_TRACK_PLAYBACK_DURATION, duration); + return this; + } + /** + * @return {Number} + */ + + + getTrackPlaybackDuration() { + return this.getParameter(MediaServiceData.KEY_TRACK_PLAYBACK_DURATION); + } + /** + * @param {Number} progress - Music: The current progress of the playback queue in seconds Podcast: The current + * progress of the playback queue in seconds Audiobook: The current progress of the + * playback queue (e.g. the book) in seconds + * @return {MediaServiceData} + */ + + + setQueuePlaybackProgress(progress) { + this.setParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS, progress); + return this; + } + /** + * @return {Number} + */ + + + getQueuePlaybackProgress() { + return this.getParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS); + } + /** + * @param {Number} duration - Music: The total duration of the playback queue in seconds Podcast: The total duration + * of the playback queue in seconds Audiobook: The total duration of the playback queue + * (e.g. the book) in seconds + * @return {MediaServiceData} + */ + + + setQueuePlaybackDuration(duration) { + this.setParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION, duration); + return this; + } + /** + * @return {Number} + */ + + + getQueuePlaybackDuration() { + return this.getParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION); + } + /** + * @param {Number} number - Music: The current number (1 based) of the track in the playback queue Podcast: The + * current number (1 based) of the episode in the playback queue Audiobook: The current + * number (1 based) of the episode in the playback queue (e.g. the chapter number in the + * book) + * @return {MediaServiceData} + */ + + + setQueueCurrentTrackNumber(number) { + this.setParameter(MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER, number); + return this; + } + /** + * @return {Number} + */ + + + getQueueCurrentTrackNumber() { + return this.getParameter(MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER); + } + /** + * @param {Number} count - Music: The total number of tracks in the playback queue Podcast: The total number of + * episodes in the playback queue Audiobook: The total number of sections in the playback + * queue (e.g. the number of chapters in the book) + * @return {MediaServiceData} + */ + + + setQueueTotalTrackCount(count) { + this.setParameter(MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT, count); + return this; + } + /** + * @return {Number} + */ + + + getQueueTotalTrackCount() { + return this.getParameter(MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT); + } + /** + * @param {Image} image - Music: The album art of the current track Podcast: The podcast or chapter artwork of the + * current podcast episode Audiobook: The book or chapter artwork of the current audiobook + * @return {MediaServiceData} + */ + + + setMediaImage(image) { + this.validateType(Image, image); + this.setParameter(MediaServiceData.KEY_MEDIA_IMAGE, image); + return this; + } + /** + * @return {Image} + */ + + + getMediaImage() { + return this.getObject(Image, MediaServiceData.KEY_MEDIA_IMAGE); + } + + } + + MediaServiceData.KEY_MEDIA_TYPE = 'mediaType'; + MediaServiceData.KEY_MEDIA_TITLE = 'mediaTitle'; + MediaServiceData.KEY_MEDIA_ARTIST = 'mediaArtist'; + MediaServiceData.KEY_MEDIA_ALBUM = 'mediaAlbum'; + MediaServiceData.KEY_PLAYLIST_NAME = 'playlistName'; + MediaServiceData.KEY_IS_EXPLICIT = 'isExplicit'; + MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS = 'trackPlaybackProgress'; + MediaServiceData.KEY_TRACK_PLAYBACK_DURATION = 'trackPlaybackDuration'; + MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS = 'queuePlaybackProgress'; + MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION = 'queuePlaybackDuration'; + MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER = 'queueCurrentTrackNumber'; + MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT = 'queueTotalTrackCount'; + MediaServiceData.KEY_MEDIA_IMAGE = 'mediaImage'; + + /* eslint-disable camelcase */ + + class WeatherData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Temperature} temperature + * @return {WeatherData} + */ + + + setCurrentTemperature(temperature) { + this.validateType(Temperature, temperature); + this.setParameter(WeatherData.KEY_CURRENT_TEMPERATURE, temperature); + return this; + } + /** + * @return {Temperature} + */ + + + getCurrentTemperature() { + return this.getObject(Temperature, WeatherData.KEY_CURRENT_TEMPERATURE); + } + /** + * @param {Temperature} high + * @return {WeatherData} + */ + + + setTemperatureHigh(high) { + this.validateType(Temperature, high); + this.setParameter(WeatherData.KEY_TEMPERATURE_HIGH, high); + return this; + } + /** + * @return {Temperature} + */ + + + getTemperatureHigh() { + return this.getObject(Temperature, WeatherData.KEY_TEMPERATURE_HIGH); + } + /** + * @param {Temperature} low + * @return {WeatherData} + */ + + + setTemperatureLow(low) { + this.validateType(Temperature, low); + this.setParameter(WeatherData.KEY_TEMPERATURE_LOW, low); + return this; + } + /** + * @return {Temperature} + */ + + + getTemperatureLow() { + return this.getObject(Temperature, WeatherData.KEY_TEMPERATURE_LOW); + } + /** + * @param {Temperature} temperature + * @return {WeatherData} + */ + + + setApparentTemperature(temperature) { + this.validateType(Temperature, temperature); + this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE, temperature); + return this; + } + /** + * @return {Temperature} + */ + + + getApparentTemperature() { + return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE); + } + /** + * @param {Temperature} high + * @return {WeatherData} + */ + + + setApparentTemperatureHigh(high) { + this.validateType(Temperature, high); + this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE_HIGH, high); + return this; + } + /** + * @return {Temperature} + */ + + + getApparentTemperatureHigh() { + return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE_HIGH); + } + /** + * @param {Temperature} low + * @return {WeatherData} + */ + + + setApparentTemperatureLow(low) { + this.validateType(Temperature, low); + this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE_LOW, low); + return this; + } + /** + * @return {Temperature} + */ + + + getApparentTemperatureLow() { + return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE_LOW); + } + /** + * @param {String} summary + * @return {WeatherData} + */ + + + setWeatherSummary(summary) { + this.setParameter(WeatherData.KEY_WEATHER_SUMMARY, summary); + return this; + } + /** + * @return {String} + */ + + + getWeatherSummary() { + return this.getParameter(WeatherData.KEY_WEATHER_SUMMARY); + } + /** + * @param {DateTime} time + * @return {WeatherData} + */ + + + setTime(time) { + this.validateType(DateTime, time); + this.setParameter(WeatherData.KEY_TIME, time); + return this; + } + /** + * @return {DateTime} + */ + + + getTime() { + return this.getObject(DateTime, WeatherData.KEY_TIME); + } + /** + * @param {Number} humidity - 0 to 1, percentage humidity + * @return {WeatherData} + */ + + + setHumidity(humidity) { + this.setParameter(WeatherData.KEY_HUMIDITY, humidity); + return this; + } + /** + * @return {Number} + */ + + + getHumidity() { + return this.getParameter(WeatherData.KEY_HUMIDITY); + } + /** + * @param {Number} cover - 0 to 1, percentage cloud cover + * @return {WeatherData} + */ + + + setCloudCover(cover) { + this.setParameter(WeatherData.KEY_CLOUD_COVER, cover); + return this; + } + /** + * @return {Number} + */ + + + getCloudCover() { + return this.getParameter(WeatherData.KEY_CLOUD_COVER); + } + /** + * @param {Number} phase - 0 to 1, percentage of the moon seen, e.g. 0 = no moon, 0.25 = quarter moon + * @return {WeatherData} + */ + + + setMoonPhase(phase) { + this.setParameter(WeatherData.KEY_MOON_PHASE, phase); + return this; + } + /** + * @return {Number} + */ + + + getMoonPhase() { + return this.getParameter(WeatherData.KEY_MOON_PHASE); + } + /** + * @param {Number} bearing - In degrees, true north at 0 degrees + * @return {WeatherData} + */ + + + setWindBearing(bearing) { + this.setParameter(WeatherData.KEY_WIND_BEARING, bearing); + return this; + } + /** + * @return {Number} + */ + + + getWindBearing() { + return this.getParameter(WeatherData.KEY_WIND_BEARING); + } + /** + * @param {Number} gust - km/hr + * @return {WeatherData} + */ + + + setWindGust(gust) { + this.setParameter(WeatherData.KEY_WIND_GUST, gust); + return this; + } + /** + * @return {Number} + */ + + + getWindGust() { + return this.getParameter(WeatherData.KEY_WIND_GUST); + } + /** + * @param {Number} speed - km/hr + * @return {WeatherData} + */ + + + setWindSpeed(speed) { + this.setParameter(WeatherData.KEY_WIND_SPEED, speed); + return this; + } + /** + * @return {Number} + */ + + + getWindSpeed() { + return this.getParameter(WeatherData.KEY_WIND_SPEED); + } + /** + * @param {Number} bearing - In degrees, true north at 0 degrees + * @return {WeatherData} + */ + + + setNearestStormBearing(bearing) { + this.setParameter(WeatherData.KEY_NEAREST_STORM_BEARING, bearing); + return this; + } + /** + * @return {Number} + */ + + + getNearestStormBearing() { + return this.getParameter(WeatherData.KEY_NEAREST_STORM_BEARING); + } + /** + * @param {Number} distance - In km + * @return {WeatherData} + */ + + + setNearestStormDistance(distance) { + this.setParameter(WeatherData.KEY_NEAREST_STORM_DISTANCE, distance); + return this; + } + /** + * @return {Number} + */ + + + getNearestStormDistance() { + return this.getParameter(WeatherData.KEY_NEAREST_STORM_DISTANCE); + } + /** + * @param {Number} accumulation - cm + * @return {WeatherData} + */ + + + setPrecipAccumulation(accumulation) { + this.setParameter(WeatherData.KEY_PRECIP_ACCUMULATION, accumulation); + return this; + } + /** + * @return {Number} + */ + + + getPrecipAccumulation() { + return this.getParameter(WeatherData.KEY_PRECIP_ACCUMULATION); + } + /** + * @param {Number} intensity - cm of water per hour + * @return {WeatherData} + */ + + + setPrecipIntensity(intensity) { + this.setParameter(WeatherData.KEY_PRECIP_INTENSITY, intensity); + return this; + } + /** + * @return {Number} + */ + + + getPrecipIntensity() { + return this.getParameter(WeatherData.KEY_PRECIP_INTENSITY); + } + /** + * @param {Number} probability - 0 to 1, percentage chance + * @return {WeatherData} + */ + + + setPrecipProbability(probability) { + this.setParameter(WeatherData.KEY_PRECIP_PROBABILITY, probability); + return this; + } + /** + * @return {Number} + */ + + + getPrecipProbability() { + return this.getParameter(WeatherData.KEY_PRECIP_PROBABILITY); + } + /** + * @param {String} type - e.g. "rain", "snow", "sleet", "hail" + * @return {WeatherData} + */ + + + setPrecipType(type) { + this.setParameter(WeatherData.KEY_PRECIP_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getPrecipType() { + return this.getParameter(WeatherData.KEY_PRECIP_TYPE); + } + /** + * @param {Number} visibility - In km + * @return {WeatherData} + */ + + + setVisibility(visibility) { + this.setParameter(WeatherData.KEY_VISIBILITY, visibility); + return this; + } + /** + * @return {Number} + */ + + + getVisibility() { + return this.getParameter(WeatherData.KEY_VISIBILITY); + } + /** + * @param {Image} icon + * @return {WeatherData} + */ + + + setWeatherIcon(icon) { + this.validateType(Image, icon); + this.setParameter(WeatherData.KEY_WEATHER_ICON, icon); + return this; + } + /** + * @return {Image} + */ + + + getWeatherIcon() { + return this.getObject(Image, WeatherData.KEY_WEATHER_ICON); + } + + } + + WeatherData.KEY_CURRENT_TEMPERATURE = 'currentTemperature'; + WeatherData.KEY_TEMPERATURE_HIGH = 'temperatureHigh'; + WeatherData.KEY_TEMPERATURE_LOW = 'temperatureLow'; + WeatherData.KEY_APPARENT_TEMPERATURE = 'apparentTemperature'; + WeatherData.KEY_APPARENT_TEMPERATURE_HIGH = 'apparentTemperatureHigh'; + WeatherData.KEY_APPARENT_TEMPERATURE_LOW = 'apparentTemperatureLow'; + WeatherData.KEY_WEATHER_SUMMARY = 'weatherSummary'; + WeatherData.KEY_TIME = 'time'; + WeatherData.KEY_HUMIDITY = 'humidity'; + WeatherData.KEY_CLOUD_COVER = 'cloudCover'; + WeatherData.KEY_MOON_PHASE = 'moonPhase'; + WeatherData.KEY_WIND_BEARING = 'windBearing'; + WeatherData.KEY_WIND_GUST = 'windGust'; + WeatherData.KEY_WIND_SPEED = 'windSpeed'; + WeatherData.KEY_NEAREST_STORM_BEARING = 'nearestStormBearing'; + WeatherData.KEY_NEAREST_STORM_DISTANCE = 'nearestStormDistance'; + WeatherData.KEY_PRECIP_ACCUMULATION = 'precipAccumulation'; + WeatherData.KEY_PRECIP_INTENSITY = 'precipIntensity'; + WeatherData.KEY_PRECIP_PROBABILITY = 'precipProbability'; + WeatherData.KEY_PRECIP_TYPE = 'precipType'; + WeatherData.KEY_VISIBILITY = 'visibility'; + WeatherData.KEY_WEATHER_ICON = 'weatherIcon'; + + /* eslint-disable camelcase */ + + class WeatherAlert extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} title + * @return {WeatherAlert} + */ + + + setTitle(title) { + this.setParameter(WeatherAlert.KEY_TITLE, title); + return this; + } + /** + * @return {String} + */ + + + getTitle() { + return this.getParameter(WeatherAlert.KEY_TITLE); + } + /** + * @param {String} summary + * @return {WeatherAlert} + */ + + + setSummary(summary) { + this.setParameter(WeatherAlert.KEY_SUMMARY, summary); + return this; + } + /** + * @return {String} + */ + + + getSummary() { + return this.getParameter(WeatherAlert.KEY_SUMMARY); + } + /** + * @param {DateTime} expires + * @return {WeatherAlert} + */ + + + setExpires(expires) { + this.validateType(DateTime, expires); + this.setParameter(WeatherAlert.KEY_EXPIRES, expires); + return this; + } + /** + * @return {DateTime} + */ + + + getExpires() { + return this.getObject(DateTime, WeatherAlert.KEY_EXPIRES); + } + /** + * @param {String[]} regions + * @return {WeatherAlert} + */ + + + setRegions(regions) { + this.setParameter(WeatherAlert.KEY_REGIONS, regions); + return this; + } + /** + * @return {String[]} + */ + + + getRegions() { + return this.getParameter(WeatherAlert.KEY_REGIONS); + } + /** + * @param {String} severity + * @return {WeatherAlert} + */ + + + setSeverity(severity) { + this.setParameter(WeatherAlert.KEY_SEVERITY, severity); + return this; + } + /** + * @return {String} + */ + + + getSeverity() { + return this.getParameter(WeatherAlert.KEY_SEVERITY); + } + /** + * @param {DateTime} issued + * @return {WeatherAlert} + */ + + + setTimeIssued(issued) { + this.validateType(DateTime, issued); + this.setParameter(WeatherAlert.KEY_TIME_ISSUED, issued); + return this; + } + /** + * @return {DateTime} + */ + + + getTimeIssued() { + return this.getObject(DateTime, WeatherAlert.KEY_TIME_ISSUED); + } + + } + + WeatherAlert.KEY_TITLE = 'title'; + WeatherAlert.KEY_SUMMARY = 'summary'; + WeatherAlert.KEY_EXPIRES = 'expires'; + WeatherAlert.KEY_REGIONS = 'regions'; + WeatherAlert.KEY_SEVERITY = 'severity'; + WeatherAlert.KEY_TIME_ISSUED = 'timeIssued'; + + /* eslint-disable camelcase */ + /** + * This data is related to what a weather service would provide + */ + + class WeatherServiceData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {LocationDetails} location + * @return {WeatherServiceData} + */ + + + setLocation(location) { + this.validateType(LocationDetails, location); + this.setParameter(WeatherServiceData.KEY_LOCATION, location); + return this; + } + /** + * @return {LocationDetails} + */ + + + getLocation() { + return this.getObject(LocationDetails, WeatherServiceData.KEY_LOCATION); + } + /** + * @param {WeatherData} forecast + * @return {WeatherServiceData} + */ + + + setCurrentForecast(forecast) { + this.validateType(WeatherData, forecast); + this.setParameter(WeatherServiceData.KEY_CURRENT_FORECAST, forecast); + return this; + } + /** + * @return {WeatherData} + */ + + + getCurrentForecast() { + return this.getObject(WeatherData, WeatherServiceData.KEY_CURRENT_FORECAST); + } + /** + * @param {WeatherData[]} forecast + * @return {WeatherServiceData} + */ + + + setMinuteForecast(forecast) { + this.validateType(WeatherData, forecast, true); + this.setParameter(WeatherServiceData.KEY_MINUTE_FORECAST, forecast); + return this; + } + /** + * @return {WeatherData[]} + */ + + + getMinuteForecast() { + return this.getObject(WeatherData, WeatherServiceData.KEY_MINUTE_FORECAST); + } + /** + * @param {WeatherData[]} forecast + * @return {WeatherServiceData} + */ + + + setHourlyForecast(forecast) { + this.validateType(WeatherData, forecast, true); + this.setParameter(WeatherServiceData.KEY_HOURLY_FORECAST, forecast); + return this; + } + /** + * @return {WeatherData[]} + */ + + + getHourlyForecast() { + return this.getObject(WeatherData, WeatherServiceData.KEY_HOURLY_FORECAST); + } + /** + * @param {WeatherData[]} forecast + * @return {WeatherServiceData} + */ + + + setMultidayForecast(forecast) { + this.validateType(WeatherData, forecast, true); + this.setParameter(WeatherServiceData.KEY_MULTIDAY_FORECAST, forecast); + return this; + } + /** + * @return {WeatherData[]} + */ + + + getMultidayForecast() { + return this.getObject(WeatherData, WeatherServiceData.KEY_MULTIDAY_FORECAST); + } + /** + * @param {WeatherAlert[]} alerts - This array should be ordered with the first object being the current day + * @return {WeatherServiceData} + */ + + + setAlerts(alerts) { + this.validateType(WeatherAlert, alerts, true); + this.setParameter(WeatherServiceData.KEY_ALERTS, alerts); + return this; + } + /** + * @return {WeatherAlert[]} + */ + + + getAlerts() { + return this.getObject(WeatherAlert, WeatherServiceData.KEY_ALERTS); + } + + } + + WeatherServiceData.KEY_LOCATION = 'location'; + WeatherServiceData.KEY_CURRENT_FORECAST = 'currentForecast'; + WeatherServiceData.KEY_MINUTE_FORECAST = 'minuteForecast'; + WeatherServiceData.KEY_HOURLY_FORECAST = 'hourlyForecast'; + WeatherServiceData.KEY_MULTIDAY_FORECAST = 'multidayForecast'; + WeatherServiceData.KEY_ALERTS = 'alerts'; + + /* eslint-disable camelcase */ + /** + * Contains all the current data of the app service. The serviceType will link to which of the service data objects are + * included in this object (e.g. if the service type is MEDIA, the mediaServiceData param should be included). + */ + + class AppServiceData extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum + * equivalent types. Parameter is a string to allow for new service types to be used by apps + * on older versions of SDL Core. + * @return {AppServiceData} + */ + + + setServiceType(type) { + this.setParameter(AppServiceData.KEY_SERVICE_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getServiceType() { + return this.getParameter(AppServiceData.KEY_SERVICE_TYPE); + } + /** + * @param {String} id + * @return {AppServiceData} + */ + + + setServiceID(id) { + this.setParameter(AppServiceData.KEY_SERVICE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getServiceID() { + return this.getParameter(AppServiceData.KEY_SERVICE_ID); + } + /** + * @param {MediaServiceData} data - This data is related to what a media service should provide + * @return {AppServiceData} + */ + + + setMediaServiceData(data) { + this.validateType(MediaServiceData, data); + this.setParameter(AppServiceData.KEY_MEDIA_SERVICE_DATA, data); + return this; + } + /** + * @return {MediaServiceData} + */ + + + getMediaServiceData() { + return this.getObject(MediaServiceData, AppServiceData.KEY_MEDIA_SERVICE_DATA); + } + /** + * @param {WeatherServiceData} data - This data is related to what a weather service would provide + * @return {AppServiceData} + */ + + + setWeatherServiceData(data) { + this.validateType(WeatherServiceData, data); + this.setParameter(AppServiceData.KEY_WEATHER_SERVICE_DATA, data); + return this; + } + /** + * @return {WeatherServiceData} + */ + + + getWeatherServiceData() { + return this.getObject(WeatherServiceData, AppServiceData.KEY_WEATHER_SERVICE_DATA); + } + /** + * @param {NavigationServiceData} data - This data is related to what a navigation service would provide. + * @return {AppServiceData} + */ + + + setNavigationServiceData(data) { + this.validateType(NavigationServiceData, data); + this.setParameter(AppServiceData.KEY_NAVIGATION_SERVICE_DATA, data); + return this; + } + /** + * @return {NavigationServiceData} + */ + + + getNavigationServiceData() { + return this.getObject(NavigationServiceData, AppServiceData.KEY_NAVIGATION_SERVICE_DATA); + } + + } + + AppServiceData.KEY_SERVICE_TYPE = 'serviceType'; + AppServiceData.KEY_SERVICE_ID = 'serviceID'; + AppServiceData.KEY_MEDIA_SERVICE_DATA = 'mediaServiceData'; + AppServiceData.KEY_WEATHER_SERVICE_DATA = 'weatherServiceData'; + AppServiceData.KEY_NAVIGATION_SERVICE_DATA = 'navigationServiceData'; + + /* eslint-disable camelcase */ + /** + * This response includes the data that was requested from the specific service + */ + + class GetAppServiceDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.GetAppServiceData); + } + /** + * @param {AppServiceData} data - Contains all the current data of the app service. The serviceType will link to + * which of the service data objects are included in this object (e.g. if the service + * type is MEDIA, the mediaServiceData param should be included). + * @return {GetAppServiceDataResponse} + */ + + + setServiceData(data) { + this.validateType(AppServiceData, data); + this.setParameter(GetAppServiceDataResponse.KEY_SERVICE_DATA, data); + return this; + } + /** + * @return {AppServiceData} + */ + + + getServiceData() { + return this.getObject(AppServiceData, GetAppServiceDataResponse.KEY_SERVICE_DATA); + } + + } + + GetAppServiceDataResponse.KEY_SERVICE_DATA = 'serviceData'; + + /* eslint-disable camelcase */ + + class PerformAppServiceInteraction extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PerformAppServiceInteraction); + } + /** + * @param {String} uri - Fully qualified URI based on a predetermined scheme provided by the app service. SDL makes + * no guarantee that this URI is correct. + * @return {PerformAppServiceInteraction} + */ + + + setServiceUri(uri) { + this.setParameter(PerformAppServiceInteraction.KEY_SERVICE_URI, uri); + return this; + } + /** + * @return {String} + */ + + + getServiceUri() { + return this.getParameter(PerformAppServiceInteraction.KEY_SERVICE_URI); + } + /** + * @param {String} id - The service ID that the app consumer wishes to send this URI. + * @return {PerformAppServiceInteraction} + */ + + + setServiceID(id) { + this.setParameter(PerformAppServiceInteraction.KEY_SERVICE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getServiceID() { + return this.getParameter(PerformAppServiceInteraction.KEY_SERVICE_ID); + } + /** + * @param {String} app - This string is the appID of the app requesting the app service provider take the specific + * action. + * @return {PerformAppServiceInteraction} + */ + + + setOriginApp(app) { + this.setParameter(PerformAppServiceInteraction.KEY_ORIGIN_APP, app); + return this; + } + /** + * @return {String} + */ + + + getOriginApp() { + return this.getParameter(PerformAppServiceInteraction.KEY_ORIGIN_APP); + } + /** + * @param {Boolean} active - This flag signals the requesting consumer would like this service to become the active + * primary service of the destination's type. + * @return {PerformAppServiceInteraction} + */ + + + setRequestServiceActive(active) { + this.setParameter(PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE, active); + return this; + } + /** + * @return {Boolean} + */ + + + getRequestServiceActive() { + return this.getParameter(PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE); + } + + } + + PerformAppServiceInteraction.KEY_SERVICE_URI = 'serviceUri'; + PerformAppServiceInteraction.KEY_SERVICE_ID = 'serviceID'; + PerformAppServiceInteraction.KEY_ORIGIN_APP = 'originApp'; + PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE = 'requestServiceActive'; + + /* eslint-disable camelcase */ + + class PerformAppServiceInteractionResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.PerformAppServiceInteraction); + } + /** + * @param {String} result - The service can provide specific result strings to the consumer through this param. + * @return {PerformAppServiceInteractionResponse} + */ + + + setServiceSpecificResult(result) { + this.setParameter(PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT, result); + return this; + } + /** + * @return {String} + */ + + + getServiceSpecificResult() { + return this.getParameter(PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT); + } + + } + + PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT = 'serviceSpecificResult'; + + /* eslint-disable camelcase */ + /** + * Close an active interaction on the HMI. + */ + + class CancelInteraction extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.CancelInteraction); + } + /** + * @param {Number} id - The ID of the specific interaction you want to dismiss. If not set, the most recent of the + * RPC type set in functionID will be dismissed. + * @return {CancelInteraction} + */ + + + setCancelID(id) { + this.setParameter(CancelInteraction.KEY_CANCEL_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCancelID() { + return this.getParameter(CancelInteraction.KEY_CANCEL_ID); + } + /** + * @param {Number} id - The ID of the type of interaction the developer wants to dismiss. Only values 10, + * (PerformInteractionID), 12 (AlertID), 25 (ScrollableMessageID), and 26 (SliderID) are + * permitted. + * @return {CancelInteraction} + */ + + + setFunctionID(id) { + this.setParameter(CancelInteraction.KEY_FUNCTION_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getFunctionID() { + return this.getParameter(CancelInteraction.KEY_FUNCTION_ID); + } + + } + + CancelInteraction.KEY_CANCEL_ID = 'cancelID'; + CancelInteraction.KEY_FUNCTION_ID = 'functionID'; + + /* eslint-disable camelcase */ + /** + * If no applicable request can be dismissed, the result will be IGNORED. + */ + + class CancelInteractionResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.CancelInteraction); + } + + } + + /* eslint-disable camelcase */ + /** + * Request from the application to exit the foreground and enter HMI_NONE. + */ + + class CloseApplication extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.CloseApplication); + } + + } + + /* eslint-disable camelcase */ + + class CloseApplicationResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.CloseApplication); + } + + } + + /* eslint-disable camelcase */ + /** + * Enumeration that describes possible contexts an app's HMI might be in. Communicated to whichever app is in HMI FULL, + * except Alert. + * @typedef {Enum} SystemContext + * @property {Object} _MAP + */ + + class SystemContext extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * The app's persistent display (whether media/non-media/navigation) is fully visible onscreen. + * @return {String} + */ + + + static get SYSCTXT_MAIN() { + return SystemContext._MAP.SYSCTXT_MAIN; + } + /** + * The system is currently in a VR session (with whatever dedicated VR screen being overlaid onscreen). + * @return {String} + */ + + + static get SYSCTXT_VRSESSION() { + return SystemContext._MAP.SYSCTXT_VRSESSION; + } + /** + * The system is currently displaying an in-App menu onscreen. + * @return {String} + */ + + + static get SYSCTXT_MENU() { + return SystemContext._MAP.SYSCTXT_MENU; + } + /** + * The app's display HMI is currently being obscured by either a system or other app's overlay. + * @return {String} + */ + + + static get SYSCTXT_HMI_OBSCURED() { + return SystemContext._MAP.SYSCTXT_HMI_OBSCURED; + } + /** + * Broadcast only to whichever app has an alert currently being displayed. + * @return {String} + */ + + + static get SYSCTXT_ALERT() { + return SystemContext._MAP.SYSCTXT_ALERT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return SystemContext._valueForKey(key, SystemContext._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return SystemContext._keyForValue(value, SystemContext._MAP); + } + + } + + SystemContext._MAP = Object.freeze({ + 'SYSCTXT_MAIN': 'MAIN', + 'SYSCTXT_VRSESSION': 'VRSESSION', + 'SYSCTXT_MENU': 'MENU', + 'SYSCTXT_HMI_OBSCURED': 'HMI_OBSCURED', + 'SYSCTXT_ALERT': 'ALERT' + }); + + /* + * Copyright (c) 2019, Livio, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Livio Inc. nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + class RpcNotification extends RpcMessage { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setRPCType(RpcType.NOTIFICATION); + } + + } + + /* eslint-disable camelcase */ + /** + * Enumeration that describes possible states of audio streaming. + * @typedef {Enum} AudioStreamingState + * @property {Object} _MAP + */ + + class AudioStreamingState extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get AUDIBLE() { + return AudioStreamingState._MAP.AUDIBLE; + } + /** + * @return {String} + */ + + + static get ATTENUATED() { + return AudioStreamingState._MAP.ATTENUATED; + } + /** + * @return {String} + */ + + + static get NOT_AUDIBLE() { + return AudioStreamingState._MAP.NOT_AUDIBLE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return AudioStreamingState._valueForKey(key, AudioStreamingState._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return AudioStreamingState._keyForValue(value, AudioStreamingState._MAP); + } + + } + + AudioStreamingState._MAP = Object.freeze({ + 'AUDIBLE': 'AUDIBLE', + 'ATTENUATED': 'ATTENUATED', + 'NOT_AUDIBLE': 'NOT_AUDIBLE' + }); + + /* eslint-disable camelcase */ + /** + * Enumeration that describes current levels of HMI. + * @typedef {Enum} HMILevel + * @property {Object} _MAP + */ + + class HMILevel extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get HMI_FULL() { + return HMILevel._MAP.HMI_FULL; + } + /** + * @return {String} + */ + + + static get HMI_LIMITED() { + return HMILevel._MAP.HMI_LIMITED; + } + /** + * @return {String} + */ + + + static get HMI_BACKGROUND() { + return HMILevel._MAP.HMI_BACKGROUND; + } + /** + * @return {String} + */ + + + static get HMI_NONE() { + return HMILevel._MAP.HMI_NONE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return HMILevel._valueForKey(key, HMILevel._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return HMILevel._keyForValue(value, HMILevel._MAP); + } + + } + + HMILevel._MAP = Object.freeze({ + 'HMI_FULL': 'FULL', + 'HMI_LIMITED': 'LIMITED', + 'HMI_BACKGROUND': 'BACKGROUND', + 'HMI_NONE': 'NONE' + }); + + /* eslint-disable camelcase */ + /** + * Enumeration that describes possible states of video streaming. + * @typedef {Enum} VideoStreamingState + * @property {Object} _MAP + */ + + class VideoStreamingState extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get STREAMABLE() { + return VideoStreamingState._MAP.STREAMABLE; + } + /** + * @return {String} + */ + + + static get NOT_STREAMABLE() { + return VideoStreamingState._MAP.NOT_STREAMABLE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VideoStreamingState._valueForKey(key, VideoStreamingState._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VideoStreamingState._keyForValue(value, VideoStreamingState._MAP); + } + + } + + VideoStreamingState._MAP = Object.freeze({ + 'STREAMABLE': 'STREAMABLE', + 'NOT_STREAMABLE': 'NOT_STREAMABLE' + }); + + /* eslint-disable camelcase */ + + class OnHMIStatus extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnHMIStatus); + } + /** + * @param {HMILevel} level - See HMILevel + * @return {OnHMIStatus} + */ + + + setHmiLevel(level) { + this.validateType(HMILevel, level); + this.setParameter(OnHMIStatus.KEY_HMI_LEVEL, level); + return this; + } + /** + * @return {HMILevel} + */ + + + getHmiLevel() { + return this.getObject(HMILevel, OnHMIStatus.KEY_HMI_LEVEL); + } + /** + * @param {AudioStreamingState} state - See AudioStreamingState + * @return {OnHMIStatus} + */ + + + setAudioStreamingState(state) { + this.validateType(AudioStreamingState, state); + this.setParameter(OnHMIStatus.KEY_AUDIO_STREAMING_STATE, state); + return this; + } + /** + * @return {AudioStreamingState} + */ + + + getAudioStreamingState() { + return this.getObject(AudioStreamingState, OnHMIStatus.KEY_AUDIO_STREAMING_STATE); + } + /** + * @param {SystemContext} context - See SystemContext + * @return {OnHMIStatus} + */ + + + setSystemContext(context) { + this.validateType(SystemContext, context); + this.setParameter(OnHMIStatus.KEY_SYSTEM_CONTEXT, context); + return this; + } + /** + * @return {SystemContext} + */ + + + getSystemContext() { + return this.getObject(SystemContext, OnHMIStatus.KEY_SYSTEM_CONTEXT); + } + /** + * @param {VideoStreamingState} state - See VideoStreamingState. If it is NOT_STREAMABLE, the app must stop + * streaming video to SDL Core(stop service). + * @return {OnHMIStatus} + */ + + + setVideoStreamingState(state) { + this.validateType(VideoStreamingState, state); + this.setParameter(OnHMIStatus.KEY_VIDEO_STREAMING_STATE, state); + return this; + } + /** + * @return {VideoStreamingState} + */ + + + getVideoStreamingState() { + return this.getObject(VideoStreamingState, OnHMIStatus.KEY_VIDEO_STREAMING_STATE); + } + /** + * @param {Number} id - This is the unique ID assigned to the window that this RPC is intended. If this param is not + * included, it will be assumed that this request is specifically for the main window on the + * main display. See PredefinedWindows enum. + * @return {OnHMIStatus} + */ + + + setWindowID(id) { + this.setParameter(OnHMIStatus.KEY_WINDOW_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getWindowID() { + return this.getParameter(OnHMIStatus.KEY_WINDOW_ID); + } + + } + + OnHMIStatus.KEY_HMI_LEVEL = 'hmiLevel'; + OnHMIStatus.KEY_AUDIO_STREAMING_STATE = 'audioStreamingState'; + OnHMIStatus.KEY_SYSTEM_CONTEXT = 'systemContext'; + OnHMIStatus.KEY_VIDEO_STREAMING_STATE = 'videoStreamingState'; + OnHMIStatus.KEY_WINDOW_ID = 'windowID'; + + /* eslint-disable camelcase */ + /** + * Error code, which comes from the module side. + * @typedef {Enum} AppInterfaceUnregisteredReason + * @property {Object} _MAP + */ + + class AppInterfaceUnregisteredReason extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get IGNITION_OFF() { + return AppInterfaceUnregisteredReason._MAP.IGNITION_OFF; + } + /** + * @return {String} + */ + + + static get BLUETOOTH_OFF() { + return AppInterfaceUnregisteredReason._MAP.BLUETOOTH_OFF; + } + /** + * @return {String} + */ + + + static get USB_DISCONNECTED() { + return AppInterfaceUnregisteredReason._MAP.USB_DISCONNECTED; + } + /** + * @return {String} + */ + + + static get REQUEST_WHILE_IN_NONE_HMI_LEVEL() { + return AppInterfaceUnregisteredReason._MAP.REQUEST_WHILE_IN_NONE_HMI_LEVEL; + } + /** + * @return {String} + */ + + + static get TOO_MANY_REQUESTS() { + return AppInterfaceUnregisteredReason._MAP.TOO_MANY_REQUESTS; + } + /** + * @return {String} + */ + + + static get DRIVER_DISTRACTION_VIOLATION() { + return AppInterfaceUnregisteredReason._MAP.DRIVER_DISTRACTION_VIOLATION; + } + /** + * @return {String} + */ + + + static get LANGUAGE_CHANGE() { + return AppInterfaceUnregisteredReason._MAP.LANGUAGE_CHANGE; + } + /** + * @return {String} + */ + + + static get MASTER_RESET() { + return AppInterfaceUnregisteredReason._MAP.MASTER_RESET; + } + /** + * @return {String} + */ + + + static get FACTORY_DEFAULTS() { + return AppInterfaceUnregisteredReason._MAP.FACTORY_DEFAULTS; + } + /** + * @return {String} + */ + + + static get APP_UNAUTHORIZED() { + return AppInterfaceUnregisteredReason._MAP.APP_UNAUTHORIZED; + } + /** + * @return {String} + */ + + + static get PROTOCOL_VIOLATION() { + return AppInterfaceUnregisteredReason._MAP.PROTOCOL_VIOLATION; + } + /** + * @return {String} + */ + + + static get UNSUPPORTED_HMI_RESOURCE() { + return AppInterfaceUnregisteredReason._MAP.UNSUPPORTED_HMI_RESOURCE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return AppInterfaceUnregisteredReason._valueForKey(key, AppInterfaceUnregisteredReason._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return AppInterfaceUnregisteredReason._keyForValue(value, AppInterfaceUnregisteredReason._MAP); + } + + } + + AppInterfaceUnregisteredReason._MAP = Object.freeze({ + 'IGNITION_OFF': 'IGNITION_OFF', + 'BLUETOOTH_OFF': 'BLUETOOTH_OFF', + 'USB_DISCONNECTED': 'USB_DISCONNECTED', + 'REQUEST_WHILE_IN_NONE_HMI_LEVEL': 'REQUEST_WHILE_IN_NONE_HMI_LEVEL', + 'TOO_MANY_REQUESTS': 'TOO_MANY_REQUESTS', + 'DRIVER_DISTRACTION_VIOLATION': 'DRIVER_DISTRACTION_VIOLATION', + 'LANGUAGE_CHANGE': 'LANGUAGE_CHANGE', + 'MASTER_RESET': 'MASTER_RESET', + 'FACTORY_DEFAULTS': 'FACTORY_DEFAULTS', + 'APP_UNAUTHORIZED': 'APP_UNAUTHORIZED', + 'PROTOCOL_VIOLATION': 'PROTOCOL_VIOLATION', + 'UNSUPPORTED_HMI_RESOURCE': 'UNSUPPORTED_HMI_RESOURCE' + }); + + /* eslint-disable camelcase */ + + class OnAppInterfaceUnregistered extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnAppInterfaceUnregistered); + } + /** + * @param {AppInterfaceUnregisteredReason} reason - See AppInterfaceUnregisteredReason + * @return {OnAppInterfaceUnregistered} + */ + + + setReason(reason) { + this.validateType(AppInterfaceUnregisteredReason, reason); + this.setParameter(OnAppInterfaceUnregistered.KEY_REASON, reason); + return this; + } + /** + * @return {AppInterfaceUnregisteredReason} + */ + + + getReason() { + return this.getObject(AppInterfaceUnregisteredReason, OnAppInterfaceUnregistered.KEY_REASON); + } + + } + + OnAppInterfaceUnregistered.KEY_REASON = 'reason'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} ButtonEventMode + * @property {Object} _MAP + */ + + class ButtonEventMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * A button has been released up + * @return {String} + */ + + + static get BUTTONUP() { + return ButtonEventMode._MAP.BUTTONUP; + } + /** + * A button has been pressed down + * @return {String} + */ + + + static get BUTTONDOWN() { + return ButtonEventMode._MAP.BUTTONDOWN; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return ButtonEventMode._valueForKey(key, ButtonEventMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return ButtonEventMode._keyForValue(value, ButtonEventMode._MAP); + } + + } + + ButtonEventMode._MAP = Object.freeze({ + 'BUTTONUP': 'BUTTONUP', + 'BUTTONDOWN': 'BUTTONDOWN' + }); + + /* eslint-disable camelcase */ + /** + * Notifies application of UP/DOWN events for buttons to which the application is subscribed. + */ + + class OnButtonEvent extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnButtonEvent); + } + /** + * @param {ButtonName} name - Defines the hard (physical) and soft (touchscreen) buttons available from the module + * @return {OnButtonEvent} + */ + + + setButtonName(name) { + this.validateType(ButtonName, name); + this.setParameter(OnButtonEvent.KEY_BUTTON_NAME, name); + return this; + } + /** + * @return {ButtonName} + */ + + + getButtonName() { + return this.getObject(ButtonName, OnButtonEvent.KEY_BUTTON_NAME); + } + /** + * @param {ButtonEventMode} mode - Indicates whether this is an UP or DOWN event. + * @return {OnButtonEvent} + */ + + + setButtonEventMode(mode) { + this.validateType(ButtonEventMode, mode); + this.setParameter(OnButtonEvent.KEY_BUTTON_EVENT_MODE, mode); + return this; + } + /** + * @return {ButtonEventMode} + */ + + + getButtonEventMode() { + return this.getObject(ButtonEventMode, OnButtonEvent.KEY_BUTTON_EVENT_MODE); + } + /** + * @param {Number} id - If ButtonName is "CUSTOM_BUTTON", this references the integer ID passed by a custom button. + * (e.g. softButton ID) + * @return {OnButtonEvent} + */ + + + setCustomButtonID(id) { + this.setParameter(OnButtonEvent.KEY_CUSTOM_BUTTON_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCustomButtonID() { + return this.getParameter(OnButtonEvent.KEY_CUSTOM_BUTTON_ID); + } + + } + + OnButtonEvent.KEY_BUTTON_NAME = 'buttonName'; + OnButtonEvent.KEY_BUTTON_EVENT_MODE = 'buttonEventMode'; + OnButtonEvent.KEY_CUSTOM_BUTTON_ID = 'customButtonID'; + + /* eslint-disable camelcase */ + /** + * Notifies application of LONG/SHORT press events for buttons to which the application is subscribed. + */ + + class OnButtonPress extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnButtonPress); + } + /** + * @param {ButtonName} name - Defines the hard (physical) and soft (touchscreen) buttons available from the module + * @return {OnButtonPress} + */ + + + setButtonName(name) { + this.validateType(ButtonName, name); + this.setParameter(OnButtonPress.KEY_BUTTON_NAME, name); + return this; + } + /** + * @return {ButtonName} + */ + + + getButtonName() { + return this.getObject(ButtonName, OnButtonPress.KEY_BUTTON_NAME); + } + /** + * @param {ButtonPressMode} mode - Indicates whether this is a LONG or SHORT button press event. + * @return {OnButtonPress} + */ + + + setButtonPressMode(mode) { + this.validateType(ButtonPressMode, mode); + this.setParameter(OnButtonPress.KEY_BUTTON_PRESS_MODE, mode); + return this; + } + /** + * @return {ButtonPressMode} + */ + + + getButtonPressMode() { + return this.getObject(ButtonPressMode, OnButtonPress.KEY_BUTTON_PRESS_MODE); + } + /** + * @param {Number} id - If ButtonName is "CUSTOM_BUTTON", this references the integer ID passed by a custom button. + * (e.g. softButton ID) + * @return {OnButtonPress} + */ + + + setCustomButtonID(id) { + this.setParameter(OnButtonPress.KEY_CUSTOM_BUTTON_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCustomButtonID() { + return this.getParameter(OnButtonPress.KEY_CUSTOM_BUTTON_ID); + } + + } + + OnButtonPress.KEY_BUTTON_NAME = 'buttonName'; + OnButtonPress.KEY_BUTTON_PRESS_MODE = 'buttonPressMode'; + OnButtonPress.KEY_CUSTOM_BUTTON_ID = 'customButtonID'; + + /* eslint-disable camelcase */ + /** + * Callback for the periodic and non periodic vehicle data read function. + */ + + class OnVehicleData extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnVehicleData); + } + /** + * @param {GPSData} gps - See GPSData + * @return {OnVehicleData} + */ + + + setGps(gps) { + this.validateType(GPSData, gps); + this.setParameter(OnVehicleData.KEY_GPS, gps); + return this; + } + /** + * @return {GPSData} + */ + + + getGps() { + return this.getObject(GPSData, OnVehicleData.KEY_GPS); + } + /** + * @param {Number} speed - The vehicle speed in kilometers per hour + * @return {OnVehicleData} + */ + + + setSpeed(speed) { + this.setParameter(OnVehicleData.KEY_SPEED, speed); + return this; + } + /** + * @return {Number} + */ + + + getSpeed() { + return this.getParameter(OnVehicleData.KEY_SPEED); + } + /** + * @param {Number} rpm - The number of revolutions per minute of the engine + * @return {OnVehicleData} + */ + + + setRpm(rpm) { + this.setParameter(OnVehicleData.KEY_RPM, rpm); + return this; + } + /** + * @return {Number} + */ + + + getRpm() { + return this.getParameter(OnVehicleData.KEY_RPM); + } + /** + * @param {Number} level - The fuel level in the tank (percentage) + * @return {OnVehicleData} + */ + + + setFuelLevel(level) { + this.setParameter(OnVehicleData.KEY_FUEL_LEVEL, level); + return this; + } + /** + * @return {Number} + */ + + + getFuelLevel() { + return this.getParameter(OnVehicleData.KEY_FUEL_LEVEL); + } + /** + * @param {ComponentVolumeStatus} level_state - The fuel level state + * @return {OnVehicleData} + */ + + + setFuelLevel_State(level_state) { + this.validateType(ComponentVolumeStatus, level_state); + this.setParameter(OnVehicleData.KEY_FUEL_LEVEL_STATE, level_state); + return this; + } + /** + * @return {ComponentVolumeStatus} + */ + + + getFuelLevel_State() { + return this.getObject(ComponentVolumeStatus, OnVehicleData.KEY_FUEL_LEVEL_STATE); + } + /** + * @param {Number} consumption - The instantaneous fuel consumption in microlitres + * @return {OnVehicleData} + */ + + + setInstantFuelConsumption(consumption) { + this.setParameter(OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption); + return this; + } + /** + * @return {Number} + */ + + + getInstantFuelConsumption() { + return this.getParameter(OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION); + } + /** + * @param {FuelRange[]} range - The estimate range in KM the vehicle can travel based on fuel level and consumption + * @return {OnVehicleData} + */ + + + setFuelRange(range) { + this.validateType(FuelRange, range, true); + this.setParameter(OnVehicleData.KEY_FUEL_RANGE, range); + return this; + } + /** + * @return {FuelRange[]} + */ + + + getFuelRange() { + return this.getObject(FuelRange, OnVehicleData.KEY_FUEL_RANGE); + } + /** + * @param {Number} temperature - The external temperature in degrees celsius + * @return {OnVehicleData} + */ + + + setExternalTemperature(temperature) { + this.setParameter(OnVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature); + return this; + } + /** + * @return {Number} + */ + + + getExternalTemperature() { + return this.getParameter(OnVehicleData.KEY_EXTERNAL_TEMPERATURE); + } + /** + * @param {TurnSignal} signal - See TurnSignal + * @return {OnVehicleData} + */ + + + setTurnSignal(signal) { + this.validateType(TurnSignal, signal); + this.setParameter(OnVehicleData.KEY_TURN_SIGNAL, signal); + return this; + } + /** + * @return {TurnSignal} + */ + + + getTurnSignal() { + return this.getObject(TurnSignal, OnVehicleData.KEY_TURN_SIGNAL); + } + /** + * @param {String} vin - Vehicle identification number. + * @return {OnVehicleData} + */ + + + setVin(vin) { + this.setParameter(OnVehicleData.KEY_VIN, vin); + return this; + } + /** + * @return {String} + */ + + + getVin() { + return this.getParameter(OnVehicleData.KEY_VIN); + } + /** + * @param {PRNDL} prndl - See PRNDL + * @return {OnVehicleData} + */ + + + setPrndl(prndl) { + this.validateType(PRNDL, prndl); + this.setParameter(OnVehicleData.KEY_PRNDL, prndl); + return this; + } + /** + * @return {PRNDL} + */ + + + getPrndl() { + return this.getObject(PRNDL, OnVehicleData.KEY_PRNDL); + } + /** + * @param {TireStatus} pressure - See TireStatus + * @return {OnVehicleData} + */ + + + setTirePressure(pressure) { + this.validateType(TireStatus, pressure); + this.setParameter(OnVehicleData.KEY_TIRE_PRESSURE, pressure); + return this; + } + /** + * @return {TireStatus} + */ + + + getTirePressure() { + return this.getObject(TireStatus, OnVehicleData.KEY_TIRE_PRESSURE); + } + /** + * @param {Number} odometer - Odometer in km + * @return {OnVehicleData} + */ + + + setOdometer(odometer) { + this.setParameter(OnVehicleData.KEY_ODOMETER, odometer); + return this; + } + /** + * @return {Number} + */ + + + getOdometer() { + return this.getParameter(OnVehicleData.KEY_ODOMETER); + } + /** + * @param {BeltStatus} status - The status of the seat belts + * @return {OnVehicleData} + */ + + + setBeltStatus(status) { + this.validateType(BeltStatus, status); + this.setParameter(OnVehicleData.KEY_BELT_STATUS, status); + return this; + } + /** + * @return {BeltStatus} + */ + + + getBeltStatus() { + return this.getObject(BeltStatus, OnVehicleData.KEY_BELT_STATUS); + } + /** + * @param {BodyInformation} information - The body information including power modes + * @return {OnVehicleData} + */ + + + setBodyInformation(information) { + this.validateType(BodyInformation, information); + this.setParameter(OnVehicleData.KEY_BODY_INFORMATION, information); + return this; + } + /** + * @return {BodyInformation} + */ + + + getBodyInformation() { + return this.getObject(BodyInformation, OnVehicleData.KEY_BODY_INFORMATION); + } + /** + * @param {DeviceStatus} status - The device status including signal and battery strength + * @return {OnVehicleData} + */ + + + setDeviceStatus(status) { + this.validateType(DeviceStatus, status); + this.setParameter(OnVehicleData.KEY_DEVICE_STATUS, status); + return this; + } + /** + * @return {DeviceStatus} + */ + + + getDeviceStatus() { + return this.getObject(DeviceStatus, OnVehicleData.KEY_DEVICE_STATUS); + } + /** + * @param {VehicleDataEventStatus} braking - The status of the brake pedal + * @return {OnVehicleData} + */ + + + setDriverBraking(braking) { + this.validateType(VehicleDataEventStatus, braking); + this.setParameter(OnVehicleData.KEY_DRIVER_BRAKING, braking); + return this; + } + /** + * @return {VehicleDataEventStatus} + */ + + + getDriverBraking() { + return this.getObject(VehicleDataEventStatus, OnVehicleData.KEY_DRIVER_BRAKING); + } + /** + * @param {WiperStatus} status - The status of the wipers + * @return {OnVehicleData} + */ + + + setWiperStatus(status) { + this.validateType(WiperStatus, status); + this.setParameter(OnVehicleData.KEY_WIPER_STATUS, status); + return this; + } + /** + * @return {WiperStatus} + */ + + + getWiperStatus() { + return this.getObject(WiperStatus, OnVehicleData.KEY_WIPER_STATUS); + } + /** + * @param {HeadLampStatus} status - Status of the head lamps + * @return {OnVehicleData} + */ + + + setHeadLampStatus(status) { + this.validateType(HeadLampStatus, status); + this.setParameter(OnVehicleData.KEY_HEAD_LAMP_STATUS, status); + return this; + } + /** + * @return {HeadLampStatus} + */ + + + getHeadLampStatus() { + return this.getObject(HeadLampStatus, OnVehicleData.KEY_HEAD_LAMP_STATUS); + } + /** + * @param {Number} torque - Torque value for engine (in Nm) on non-diesel variants + * @return {OnVehicleData} + */ + + + setEngineTorque(torque) { + this.setParameter(OnVehicleData.KEY_ENGINE_TORQUE, torque); + return this; + } + /** + * @return {Number} + */ + + + getEngineTorque() { + return this.getParameter(OnVehicleData.KEY_ENGINE_TORQUE); + } + /** + * @param {Number} position - Accelerator pedal position (percentage depressed) + * @return {OnVehicleData} + */ + + + setAccPedalPosition(position) { + this.setParameter(OnVehicleData.KEY_ACC_PEDAL_POSITION, position); + return this; + } + /** + * @return {Number} + */ + + + getAccPedalPosition() { + return this.getParameter(OnVehicleData.KEY_ACC_PEDAL_POSITION); + } + /** + * @param {Number} angle - Current angle of the steering wheel (in deg) + * @return {OnVehicleData} + */ + + + setSteeringWheelAngle(angle) { + this.setParameter(OnVehicleData.KEY_STEERING_WHEEL_ANGLE, angle); + return this; + } + /** + * @return {Number} + */ + + + getSteeringWheelAngle() { + return this.getParameter(OnVehicleData.KEY_STEERING_WHEEL_ANGLE); + } + /** + * @param {Number} life - The estimated percentage of remaining oil life of the engine. + * @return {OnVehicleData} + */ + + + setEngineOilLife(life) { + this.setParameter(OnVehicleData.KEY_ENGINE_OIL_LIFE, life); + return this; + } + /** + * @return {Number} + */ + + + getEngineOilLife() { + return this.getParameter(OnVehicleData.KEY_ENGINE_OIL_LIFE); + } + /** + * @param {ElectronicParkBrakeStatus} status - The status of the park brake as provided by Electric Park Brake (EPB) + * system. + * @return {OnVehicleData} + */ + + + setElectronicParkBrakeStatus(status) { + this.validateType(ElectronicParkBrakeStatus, status); + this.setParameter(OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status); + return this; + } + /** + * @return {ElectronicParkBrakeStatus} + */ + + + getElectronicParkBrakeStatus() { + return this.getObject(ElectronicParkBrakeStatus, OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS); + } + /** + * @param {String} id - Parameter used by cloud apps to identify a head unit + * @return {OnVehicleData} + */ + + + setCloudAppVehicleID(id) { + this.setParameter(OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id); + return this; + } + /** + * @return {String} + */ + + + getCloudAppVehicleID() { + return this.getParameter(OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID); + } + /** + * @param {ECallInfo} info - Emergency Call notification and confirmation data + * @return {OnVehicleData} + */ + + + setECallInfo(info) { + this.validateType(ECallInfo, info); + this.setParameter(OnVehicleData.KEY_E_CALL_INFO, info); + return this; + } + /** + * @return {ECallInfo} + */ + + + getECallInfo() { + return this.getObject(ECallInfo, OnVehicleData.KEY_E_CALL_INFO); + } + /** + * @param {AirbagStatus} status - The status of the air bags + * @return {OnVehicleData} + */ + + + setAirbagStatus(status) { + this.validateType(AirbagStatus, status); + this.setParameter(OnVehicleData.KEY_AIRBAG_STATUS, status); + return this; + } + /** + * @return {AirbagStatus} + */ + + + getAirbagStatus() { + return this.getObject(AirbagStatus, OnVehicleData.KEY_AIRBAG_STATUS); + } + /** + * @param {EmergencyEvent} event - Information related to an emergency event (and if it occurred) + * @return {OnVehicleData} + */ + + + setEmergencyEvent(event) { + this.validateType(EmergencyEvent, event); + this.setParameter(OnVehicleData.KEY_EMERGENCY_EVENT, event); + return this; + } + /** + * @return {EmergencyEvent} + */ + + + getEmergencyEvent() { + return this.getObject(EmergencyEvent, OnVehicleData.KEY_EMERGENCY_EVENT); + } + /** + * @param {ClusterModeStatus} status - The status modes of the cluster + * @return {OnVehicleData} + */ + + + setClusterModeStatus(status) { + this.validateType(ClusterModeStatus, status); + this.setParameter(OnVehicleData.KEY_CLUSTER_MODE_STATUS, status); + return this; + } + /** + * @return {ClusterModeStatus} + */ + + + getClusterModeStatus() { + return this.getObject(ClusterModeStatus, OnVehicleData.KEY_CLUSTER_MODE_STATUS); + } + /** + * @param {MyKey} key - Information related to the MyKey feature + * @return {OnVehicleData} + */ + + + setMyKey(key) { + this.validateType(MyKey, key); + this.setParameter(OnVehicleData.KEY_MY_KEY, key); + return this; + } + /** + * @return {MyKey} + */ + + + getMyKey() { + return this.getObject(MyKey, OnVehicleData.KEY_MY_KEY); + } + + } + + OnVehicleData.KEY_GPS = 'gps'; + OnVehicleData.KEY_SPEED = 'speed'; + OnVehicleData.KEY_RPM = 'rpm'; + OnVehicleData.KEY_FUEL_LEVEL = 'fuelLevel'; + OnVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State'; + OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption'; + OnVehicleData.KEY_FUEL_RANGE = 'fuelRange'; + OnVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature'; + OnVehicleData.KEY_TURN_SIGNAL = 'turnSignal'; + OnVehicleData.KEY_VIN = 'vin'; + OnVehicleData.KEY_PRNDL = 'prndl'; + OnVehicleData.KEY_TIRE_PRESSURE = 'tirePressure'; + OnVehicleData.KEY_ODOMETER = 'odometer'; + OnVehicleData.KEY_BELT_STATUS = 'beltStatus'; + OnVehicleData.KEY_BODY_INFORMATION = 'bodyInformation'; + OnVehicleData.KEY_DEVICE_STATUS = 'deviceStatus'; + OnVehicleData.KEY_DRIVER_BRAKING = 'driverBraking'; + OnVehicleData.KEY_WIPER_STATUS = 'wiperStatus'; + OnVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus'; + OnVehicleData.KEY_ENGINE_TORQUE = 'engineTorque'; + OnVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition'; + OnVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle'; + OnVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife'; + OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus'; + OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID'; + OnVehicleData.KEY_E_CALL_INFO = 'eCallInfo'; + OnVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus'; + OnVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent'; + OnVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus'; + OnVehicleData.KEY_MY_KEY = 'myKey'; + + /* eslint-disable camelcase */ + + class OnCommand extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnCommand); + } + /** + * @param {Number} id - Command ID, which is related to a specific menu entry + * @return {OnCommand} + */ + + + setCmdID(id) { + this.setParameter(OnCommand.KEY_CMD_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getCmdID() { + return this.getParameter(OnCommand.KEY_CMD_ID); + } + /** + * @param {TriggerSource} source - See TriggerSource + * @return {OnCommand} + */ + + + setTriggerSource(source) { + this.validateType(TriggerSource, source); + this.setParameter(OnCommand.KEY_TRIGGER_SOURCE, source); + return this; + } + /** + * @return {TriggerSource} + */ + + + getTriggerSource() { + return this.getObject(TriggerSource, OnCommand.KEY_TRIGGER_SOURCE); + } + + } + + OnCommand.KEY_CMD_ID = 'cmdID'; + OnCommand.KEY_TRIGGER_SOURCE = 'triggerSource'; + + /* eslint-disable camelcase */ + /** + * Enumeration that describes possible states of turn-by-turn client or SmartDeviceLink app. + * @typedef {Enum} TBTState + * @property {Object} _MAP + */ + + class TBTState extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get ROUTE_UPDATE_REQUEST() { + return TBTState._MAP.ROUTE_UPDATE_REQUEST; + } + /** + * @return {String} + */ + + + static get ROUTE_ACCEPTED() { + return TBTState._MAP.ROUTE_ACCEPTED; + } + /** + * @return {String} + */ + + + static get ROUTE_REFUSED() { + return TBTState._MAP.ROUTE_REFUSED; + } + /** + * @return {String} + */ + + + static get ROUTE_CANCELLED() { + return TBTState._MAP.ROUTE_CANCELLED; + } + /** + * @return {String} + */ + + + static get ETA_REQUEST() { + return TBTState._MAP.ETA_REQUEST; + } + /** + * @return {String} + */ + + + static get NEXT_TURN_REQUEST() { + return TBTState._MAP.NEXT_TURN_REQUEST; + } + /** + * @return {String} + */ + + + static get ROUTE_STATUS_REQUEST() { + return TBTState._MAP.ROUTE_STATUS_REQUEST; + } + /** + * @return {String} + */ + + + static get ROUTE_SUMMARY_REQUEST() { + return TBTState._MAP.ROUTE_SUMMARY_REQUEST; + } + /** + * @return {String} + */ + + + static get TRIP_STATUS_REQUEST() { + return TBTState._MAP.TRIP_STATUS_REQUEST; + } + /** + * @return {String} + */ + + + static get ROUTE_UPDATE_REQUEST_TIMEOUT() { + return TBTState._MAP.ROUTE_UPDATE_REQUEST_TIMEOUT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return TBTState._valueForKey(key, TBTState._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return TBTState._keyForValue(value, TBTState._MAP); + } + + } + + TBTState._MAP = Object.freeze({ + 'ROUTE_UPDATE_REQUEST': 'ROUTE_UPDATE_REQUEST', + 'ROUTE_ACCEPTED': 'ROUTE_ACCEPTED', + 'ROUTE_REFUSED': 'ROUTE_REFUSED', + 'ROUTE_CANCELLED': 'ROUTE_CANCELLED', + 'ETA_REQUEST': 'ETA_REQUEST', + 'NEXT_TURN_REQUEST': 'NEXT_TURN_REQUEST', + 'ROUTE_STATUS_REQUEST': 'ROUTE_STATUS_REQUEST', + 'ROUTE_SUMMARY_REQUEST': 'ROUTE_SUMMARY_REQUEST', + 'TRIP_STATUS_REQUEST': 'TRIP_STATUS_REQUEST', + 'ROUTE_UPDATE_REQUEST_TIMEOUT': 'ROUTE_UPDATE_REQUEST_TIMEOUT' + }); + + /* eslint-disable camelcase */ + /** + * Provides applications with notifications specific to the current TBT client status on the module + */ + + class OnTBTClientState extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnTBTClientState); + } + /** + * @param {TBTState} state - Current State of TBT client + * @return {OnTBTClientState} + */ + + + setState(state) { + this.validateType(TBTState, state); + this.setParameter(OnTBTClientState.KEY_STATE, state); + return this; + } + /** + * @return {TBTState} + */ + + + getState() { + return this.getObject(TBTState, OnTBTClientState.KEY_STATE); + } + + } + + OnTBTClientState.KEY_STATE = 'state'; + + /* eslint-disable camelcase */ + /** + * Enumeration that describes possible states of driver distraction. + * @typedef {Enum} DriverDistractionState + * @property {Object} _MAP + */ + + class DriverDistractionState extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get DD_ON() { + return DriverDistractionState._MAP.DD_ON; + } + /** + * @return {String} + */ + + + static get DD_OFF() { + return DriverDistractionState._MAP.DD_OFF; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return DriverDistractionState._valueForKey(key, DriverDistractionState._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return DriverDistractionState._keyForValue(value, DriverDistractionState._MAP); + } + + } + + DriverDistractionState._MAP = Object.freeze({ + 'DD_ON': 'DD_ON', + 'DD_OFF': 'DD_OFF' + }); + + /* eslint-disable camelcase */ + /** + * Provides driver distraction state to mobile applications + */ + + class OnDriverDistraction extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnDriverDistraction); + } + /** + * @param {DriverDistractionState} state - Current State of Driver Distraction + * @return {OnDriverDistraction} + */ + + + setState(state) { + this.validateType(DriverDistractionState, state); + this.setParameter(OnDriverDistraction.KEY_STATE, state); + return this; + } + /** + * @return {DriverDistractionState} + */ + + + getState() { + return this.getObject(DriverDistractionState, OnDriverDistraction.KEY_STATE); + } + /** + * @param {Boolean} enabled - If enabled, the lock screen will be able to be dismissed while connected to SDL, + * allowing users the ability to interact with the app. Dismissals should include a + * warning to the user and ensure that they are not the driver. + * @return {OnDriverDistraction} + */ + + + setLockScreenDismissalEnabled(enabled) { + this.setParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED, enabled); + return this; + } + /** + * @return {Boolean} + */ + + + getLockScreenDismissalEnabled() { + return this.getParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED); + } + /** + * @param {String} warning - Warning message to be displayed on the lock screen when dismissal is enabled. This + * warning should be used to ensure that the user is not the driver of the vehicle, ex. + * `Swipe down to dismiss, acknowledging that you are not the driver.`. This parameter + * must be present if "lockScreenDismissalEnabled" is set to true. + * @return {OnDriverDistraction} + */ + + + setLockScreenDismissalWarning(warning) { + this.setParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING, warning); + return this; + } + /** + * @return {String} + */ + + + getLockScreenDismissalWarning() { + return this.getParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING); + } + + } + + OnDriverDistraction.KEY_STATE = 'state'; + OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED = 'lockScreenDismissalEnabled'; + OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING = 'lockScreenDismissalWarning'; + + /* eslint-disable camelcase */ + + class HMIPermissions extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {HMILevel[]} allowed - A set of all HMI levels that are permitted for this given RPC. + * @return {HMIPermissions} + */ + + + setAllowed(allowed) { + this.validateType(HMILevel, allowed, true); + this.setParameter(HMIPermissions.KEY_ALLOWED, allowed); + return this; + } + /** + * @return {HMILevel[]} + */ + + + getAllowed() { + return this.getObject(HMILevel, HMIPermissions.KEY_ALLOWED); + } + /** + * @param {HMILevel[]} disallowed - A set of all HMI levels that are prohibited for this given RPC. + * @return {HMIPermissions} + */ + + + setUserDisallowed(disallowed) { + this.validateType(HMILevel, disallowed, true); + this.setParameter(HMIPermissions.KEY_USER_DISALLOWED, disallowed); + return this; + } + /** + * @return {HMILevel[]} + */ + + + getUserDisallowed() { + return this.getObject(HMILevel, HMIPermissions.KEY_USER_DISALLOWED); + } + + } + + HMIPermissions.KEY_ALLOWED = 'allowed'; + HMIPermissions.KEY_USER_DISALLOWED = 'userDisallowed'; + + /* eslint-disable camelcase */ + + class ParameterPermissions extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String[]} allowed - A set of all parameters that are permitted for this given RPC. + * @return {ParameterPermissions} + */ + + + setAllowed(allowed) { + this.setParameter(ParameterPermissions.KEY_ALLOWED, allowed); + return this; + } + /** + * @return {String[]} + */ + + + getAllowed() { + return this.getParameter(ParameterPermissions.KEY_ALLOWED); + } + /** + * @param {String[]} disallowed - A set of all parameters that are prohibited for this given RPC. + * @return {ParameterPermissions} + */ + + + setUserDisallowed(disallowed) { + this.setParameter(ParameterPermissions.KEY_USER_DISALLOWED, disallowed); + return this; + } + /** + * @return {String[]} + */ + + + getUserDisallowed() { + return this.getParameter(ParameterPermissions.KEY_USER_DISALLOWED); + } + + } + + ParameterPermissions.KEY_ALLOWED = 'allowed'; + ParameterPermissions.KEY_USER_DISALLOWED = 'userDisallowed'; + + /* eslint-disable camelcase */ + + class PermissionItem extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {String} name - Name of the individual RPC in the policy table. + * @return {PermissionItem} + */ + + + setRpcName(name) { + this.setParameter(PermissionItem.KEY_RPC_NAME, name); + return this; + } + /** + * @return {String} + */ + + + getRpcName() { + return this.getParameter(PermissionItem.KEY_RPC_NAME); + } + /** + * @param {HMIPermissions} permissions + * @return {PermissionItem} + */ + + + setHmiPermissions(permissions) { + this.validateType(HMIPermissions, permissions); + this.setParameter(PermissionItem.KEY_HMI_PERMISSIONS, permissions); + return this; + } + /** + * @return {HMIPermissions} + */ + + + getHmiPermissions() { + return this.getObject(HMIPermissions, PermissionItem.KEY_HMI_PERMISSIONS); + } + /** + * @param {ParameterPermissions} permissions + * @return {PermissionItem} + */ + + + setParameterPermissions(permissions) { + this.validateType(ParameterPermissions, permissions); + this.setParameter(PermissionItem.KEY_PARAMETER_PERMISSIONS, permissions); + return this; + } + /** + * @return {ParameterPermissions} + */ + + + getParameterPermissions() { + return this.getObject(ParameterPermissions, PermissionItem.KEY_PARAMETER_PERMISSIONS); + } + /** + * @param {Boolean} encryption + * @return {PermissionItem} + */ + + + setRequireEncryption(encryption) { + this.setParameter(PermissionItem.KEY_REQUIRE_ENCRYPTION, encryption); + return this; + } + /** + * @return {Boolean} + */ + + + getRequireEncryption() { + return this.getParameter(PermissionItem.KEY_REQUIRE_ENCRYPTION); + } + + } + + PermissionItem.KEY_RPC_NAME = 'rpcName'; + PermissionItem.KEY_HMI_PERMISSIONS = 'hmiPermissions'; + PermissionItem.KEY_PARAMETER_PERMISSIONS = 'parameterPermissions'; + PermissionItem.KEY_REQUIRE_ENCRYPTION = 'requireEncryption'; + + /* eslint-disable camelcase */ + /** + * Provides update to app of which policy-table-enabled functions are available + */ + + class OnPermissionsChange extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnPermissionsChange); + } + /** + * @param {PermissionItem[]} item - Change in permissions for a given set of RPCs + * @return {OnPermissionsChange} + */ + + + setPermissionItem(item) { + this.validateType(PermissionItem, item, true); + this.setParameter(OnPermissionsChange.KEY_PERMISSION_ITEM, item); + return this; + } + /** + * @return {PermissionItem[]} + */ + + + getPermissionItem() { + return this.getObject(PermissionItem, OnPermissionsChange.KEY_PERMISSION_ITEM); + } + /** + * @param {Boolean} encryption + * @return {OnPermissionsChange} + */ + + + setRequireEncryption(encryption) { + this.setParameter(OnPermissionsChange.KEY_REQUIRE_ENCRYPTION, encryption); + return this; + } + /** + * @return {Boolean} + */ + + + getRequireEncryption() { + return this.getParameter(OnPermissionsChange.KEY_REQUIRE_ENCRYPTION); + } + + } + + OnPermissionsChange.KEY_PERMISSION_ITEM = 'permissionItem'; + OnPermissionsChange.KEY_REQUIRE_ENCRYPTION = 'requireEncryption'; + + /* eslint-disable camelcase */ + /** + * Binary data is in binary part of hybrid msg + */ + + class OnAudioPassThru extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnAudioPassThru); + } + + } + + /* eslint-disable camelcase */ + + class OnLanguageChange extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnLanguageChange); + } + /** + * @param {Language} language - Current SDL voice engine (VR+TTS) language + * @return {OnLanguageChange} + */ + + + setLanguage(language) { + this.validateType(Language, language); + this.setParameter(OnLanguageChange.KEY_LANGUAGE, language); + return this; + } + /** + * @return {Language} + */ + + + getLanguage() { + return this.getObject(Language, OnLanguageChange.KEY_LANGUAGE); + } + /** + * @param {Language} language - Current display language + * @return {OnLanguageChange} + */ + + + setHmiDisplayLanguage(language) { + this.validateType(Language, language); + this.setParameter(OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE, language); + return this; + } + /** + * @return {Language} + */ + + + getHmiDisplayLanguage() { + return this.getObject(Language, OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE); + } + + } + + OnLanguageChange.KEY_LANGUAGE = 'language'; + OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage'; + + /* eslint-disable camelcase */ + /** + * Enumeration listing possible keyboard events. + * @typedef {Enum} KeyboardEvent + * @property {Object} _MAP + */ + + class KeyboardEvent extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get KEYPRESS() { + return KeyboardEvent._MAP.KEYPRESS; + } + /** + * @return {String} + */ + + + static get ENTRY_SUBMITTED() { + return KeyboardEvent._MAP.ENTRY_SUBMITTED; + } + /** + * @return {String} + */ + + + static get ENTRY_VOICE() { + return KeyboardEvent._MAP.ENTRY_VOICE; + } + /** + * @return {String} + */ + + + static get ENTRY_CANCELLED() { + return KeyboardEvent._MAP.ENTRY_CANCELLED; + } + /** + * @return {String} + */ + + + static get ENTRY_ABORTED() { + return KeyboardEvent._MAP.ENTRY_ABORTED; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return KeyboardEvent._valueForKey(key, KeyboardEvent._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return KeyboardEvent._keyForValue(value, KeyboardEvent._MAP); + } + + } + + KeyboardEvent._MAP = Object.freeze({ + 'KEYPRESS': 'KEYPRESS', + 'ENTRY_SUBMITTED': 'ENTRY_SUBMITTED', + 'ENTRY_VOICE': 'ENTRY_VOICE', + 'ENTRY_CANCELLED': 'ENTRY_CANCELLED', + 'ENTRY_ABORTED': 'ENTRY_ABORTED' + }); + + /* eslint-disable camelcase */ + /** + * On-screen keyboard event. Can be full string or individual keypresses depending on keyboard mode. + */ + + class OnKeyboardInput extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnKeyboardInput); + } + /** + * @param {KeyboardEvent} event - On-screen keyboard input data. + * @return {OnKeyboardInput} + */ + + + setEvent(event) { + this.validateType(KeyboardEvent, event); + this.setParameter(OnKeyboardInput.KEY_EVENT, event); + return this; + } + /** + * @return {KeyboardEvent} + */ + + + getEvent() { + return this.getObject(KeyboardEvent, OnKeyboardInput.KEY_EVENT); + } + /** + * @param {String} data - On-screen keyboard input data. For dynamic keypress events, this will be the current + * compounded string of entry text. For entry submission events, this will be the full text + * entry (this will always return regardless of the mode). For entry cancelled and entry + * aborted events, this data param will be omitted. + * @return {OnKeyboardInput} + */ + + + setData(data) { + this.setParameter(OnKeyboardInput.KEY_DATA, data); + return this; + } + /** + * @return {String} + */ + + + getData() { + return this.getParameter(OnKeyboardInput.KEY_DATA); + } + + } + + OnKeyboardInput.KEY_EVENT = 'event'; + OnKeyboardInput.KEY_DATA = 'data'; + + /* eslint-disable camelcase */ + + class TouchCoord extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} x - The x coordinate of the touch. + * @return {TouchCoord} + */ + + + setX(x) { + this.setParameter(TouchCoord.KEY_X, x); + return this; + } + /** + * @return {Number} + */ + + + getX() { + return this.getParameter(TouchCoord.KEY_X); + } + /** + * @param {Number} y - The y coordinate of the touch. + * @return {TouchCoord} + */ + + + setY(y) { + this.setParameter(TouchCoord.KEY_Y, y); + return this; + } + /** + * @return {Number} + */ + + + getY() { + return this.getParameter(TouchCoord.KEY_Y); + } + + } + + TouchCoord.KEY_X = 'x'; + TouchCoord.KEY_Y = 'y'; + + /* eslint-disable camelcase */ + + class TouchEvent extends RpcStruct { + /** + * @constructor + */ + constructor(parameters) { + super(parameters); + } + /** + * @param {Number} id - A touch's unique identifier. The application can track the current touch events by id. If a + * touch event has type begin, the id should be added to the set of touches. If a touch event + * has type end, the id should be removed from the set of touches. + * @return {TouchEvent} + */ + + + setId(id) { + this.setParameter(TouchEvent.KEY_ID, id); + return this; + } + /** + * @return {Number} + */ + + + getId() { + return this.getParameter(TouchEvent.KEY_ID); + } + /** + * @param {Number[]} ts - The time that the touch was recorded. This number can the time since the beginning of the + * session or something else as long as the units are in milliseconds. The timestamp is used + * to determined the rate of change of position of a touch. The application also uses the + * time to verify whether two touches, with different ids, are part of a single action by the + * user. If there is only a single timestamp in this array, it is the same for every + * coordinate in the coordinates array. + * @return {TouchEvent} + */ + + + setTs(ts) { + this.setParameter(TouchEvent.KEY_TS, ts); + return this; + } + /** + * @return {Number[]} + */ + + + getTs() { + return this.getParameter(TouchEvent.KEY_TS); + } + /** + * @param {TouchCoord[]} c + * @return {TouchEvent} + */ + + + setC(c) { + this.validateType(TouchCoord, c, true); + this.setParameter(TouchEvent.KEY_C, c); + return this; + } + /** + * @return {TouchCoord[]} + */ + + + getC() { + return this.getObject(TouchCoord, TouchEvent.KEY_C); + } + + } + + TouchEvent.KEY_ID = 'id'; + TouchEvent.KEY_TS = 'ts'; + TouchEvent.KEY_C = 'c'; + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} TouchType + * @property {Object} _MAP + */ + + class TouchType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get BEGIN() { + return TouchType._MAP.BEGIN; + } + /** + * @return {String} + */ + + + static get MOVE() { + return TouchType._MAP.MOVE; + } + /** + * @return {String} + */ + + + static get END() { + return TouchType._MAP.END; + } + /** + * @return {String} + */ + + + static get CANCEL() { + return TouchType._MAP.CANCEL; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return TouchType._valueForKey(key, TouchType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return TouchType._keyForValue(value, TouchType._MAP); + } + + } + + TouchType._MAP = Object.freeze({ + 'BEGIN': 'BEGIN', + 'MOVE': 'MOVE', + 'END': 'END', + 'CANCEL': 'CANCEL' + }); + + /* eslint-disable camelcase */ + /** + * Notifies about touch events on the screen's prescribed area + */ + + class OnTouchEvent extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnTouchEvent); + } + /** + * @param {TouchType} type - The type of touch event. + * @return {OnTouchEvent} + */ + + + setType(type) { + this.validateType(TouchType, type); + this.setParameter(OnTouchEvent.KEY_TYPE, type); + return this; + } + /** + * @return {TouchType} + */ + + + getType() { + return this.getObject(TouchType, OnTouchEvent.KEY_TYPE); + } + /** + * @param {TouchEvent[]} event - List of all individual touches involved in this event. + * @return {OnTouchEvent} + */ + + + setEvent(event) { + this.validateType(TouchEvent, event, true); + this.setParameter(OnTouchEvent.KEY_EVENT, event); + return this; + } + /** + * @return {TouchEvent[]} + */ + + + getEvent() { + return this.getObject(TouchEvent, OnTouchEvent.KEY_EVENT); + } + + } + + OnTouchEvent.KEY_TYPE = 'type'; + OnTouchEvent.KEY_EVENT = 'event'; + + /* eslint-disable camelcase */ + /** + * An asynchronous request from the system for specific data from the device or the cloud or response to a request from + * the device or cloud Binary data can be included in hybrid part of message for some requests (such as Authentication + * request responses) + */ + + class OnSystemRequest extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnSystemRequest); + } + /** + * @param {RequestType} type - The type of system request. + * @return {OnSystemRequest} + */ + + + setRequestType(type) { + this.validateType(RequestType, type); + this.setParameter(OnSystemRequest.KEY_REQUEST_TYPE, type); + return this; + } + /** + * @return {RequestType} + */ + + + getRequestType() { + return this.getObject(RequestType, OnSystemRequest.KEY_REQUEST_TYPE); + } + /** + * @param {String} type - This parameter is filled for supporting OEM proprietary data exchanges. + * @return {OnSystemRequest} + */ + + + setRequestSubType(type) { + this.setParameter(OnSystemRequest.KEY_REQUEST_SUB_TYPE, type); + return this; + } + /** + * @return {String} + */ + + + getRequestSubType() { + return this.getParameter(OnSystemRequest.KEY_REQUEST_SUB_TYPE); + } + /** + * @param {String} url - Optional URL for HTTP requests. If blank, the binary data shall be forwarded to the app. If + * not blank, the binary data shall be forwarded to the url with a provided timeout in + * seconds. + * @return {OnSystemRequest} + */ + + + setUrl(url) { + this.setParameter(OnSystemRequest.KEY_URL, url); + return this; + } + /** + * @return {String} + */ + + + getUrl() { + return this.getParameter(OnSystemRequest.KEY_URL); + } + /** + * @param {Number} timeout - Optional timeout for HTTP requests Required if a URL is provided + * @return {OnSystemRequest} + */ + + + setTimeout(timeout) { + this.setParameter(OnSystemRequest.KEY_TIMEOUT, timeout); + return this; + } + /** + * @return {Number} + */ + + + getTimeout() { + return this.getParameter(OnSystemRequest.KEY_TIMEOUT); + } + /** + * @param {FileType} type - Optional file type (meant for HTTP file requests). + * @return {OnSystemRequest} + */ + + + setFileType(type) { + this.validateType(FileType, type); + this.setParameter(OnSystemRequest.KEY_FILE_TYPE, type); + return this; + } + /** + * @return {FileType} + */ + + + getFileType() { + return this.getObject(FileType, OnSystemRequest.KEY_FILE_TYPE); + } + /** + * @param {Number} offset - Optional offset in bytes for resuming partial data chunks + * @return {OnSystemRequest} + */ + + + setOffset(offset) { + this.setParameter(OnSystemRequest.KEY_OFFSET, offset); + return this; + } + /** + * @return {Number} + */ + + + getOffset() { + return this.getParameter(OnSystemRequest.KEY_OFFSET); + } + /** + * @param {Number} length - Optional length in bytes for resuming partial data chunks + * @return {OnSystemRequest} + */ + + + setLength(length) { + this.setParameter(OnSystemRequest.KEY_LENGTH, length); + return this; + } + /** + * @return {Number} + */ + + + getLength() { + return this.getParameter(OnSystemRequest.KEY_LENGTH); + } + + } + + OnSystemRequest.KEY_REQUEST_TYPE = 'requestType'; + OnSystemRequest.KEY_REQUEST_SUB_TYPE = 'requestSubType'; + OnSystemRequest.KEY_URL = 'url'; + OnSystemRequest.KEY_TIMEOUT = 'timeout'; + OnSystemRequest.KEY_FILE_TYPE = 'fileType'; + OnSystemRequest.KEY_OFFSET = 'offset'; + OnSystemRequest.KEY_LENGTH = 'length'; + + /* eslint-disable camelcase */ + /** + * Notification containing an updated hashID which can be used over connection cycles (i.e. loss of connection, + * ignition cycles, etc.). Sent after initial registration and subsequently after any change in the calculated hash of + * all persisted app data. + */ + + class OnHashChange extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnHashChange); + } + /** + * @param {String} id - Calculated hash ID to be referenced during RegisterAppInterface. + * @return {OnHashChange} + */ + + + setHashID(id) { + this.setParameter(OnHashChange.KEY_HASH_ID, id); + return this; + } + /** + * @return {String} + */ + + + getHashID() { + return this.getParameter(OnHashChange.KEY_HASH_ID); + } + + } + + OnHashChange.KEY_HASH_ID = 'hashID'; + + /* eslint-disable camelcase */ + /** + * Notification which provides the entire LocationDetails when there is a change to any waypoints or destination. + */ + + class OnWayPointChange extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnWayPointChange); + } + /** + * @param {LocationDetails[]} points - See LocationDetails + * @return {OnWayPointChange} + */ + + + setWayPoints(points) { + this.validateType(LocationDetails, points, true); + this.setParameter(OnWayPointChange.KEY_WAY_POINTS, points); + return this; + } + /** + * @return {LocationDetails[]} + */ + + + getWayPoints() { + return this.getObject(LocationDetails, OnWayPointChange.KEY_WAY_POINTS); + } + + } + + OnWayPointChange.KEY_WAY_POINTS = 'wayPoints'; + + /* eslint-disable camelcase */ + + class OnInteriorVehicleData extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnInteriorVehicleData); + } + /** + * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which + * data object exists in this struct. For example, if the moduleType is CLIMATE then a + * "climateControlData" should exist + * @return {OnInteriorVehicleData} + */ + + + setModuleData(data) { + this.validateType(ModuleData, data); + this.setParameter(OnInteriorVehicleData.KEY_MODULE_DATA, data); + return this; + } + /** + * @return {ModuleData} + */ + + + getModuleData() { + return this.getObject(ModuleData, OnInteriorVehicleData.KEY_MODULE_DATA); + } + + } + + OnInteriorVehicleData.KEY_MODULE_DATA = 'moduleData'; + + /* eslint-disable camelcase */ + /** + * Issued by SDL to notify the application about remote control status change on SDL + */ + + class OnRCStatus extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnRCStatus); + } + /** + * @param {Boolean} allowed - If "true" - RC is allowed; if "false" - RC is disallowed. + * @return {OnRCStatus} + */ + + + setAllowed(allowed) { + this.setParameter(OnRCStatus.KEY_ALLOWED, allowed); + return this; + } + /** + * @return {Boolean} + */ + + + getAllowed() { + return this.getParameter(OnRCStatus.KEY_ALLOWED); + } + /** + * @param {ModuleData[]} modules - Contains a list (zero or more) of module types that are allocated to the + * application. + * @return {OnRCStatus} + */ + + + setAllocatedModules(modules) { + this.validateType(ModuleData, modules, true); + this.setParameter(OnRCStatus.KEY_ALLOCATED_MODULES, modules); + return this; + } + /** + * @return {ModuleData[]} + */ + + + getAllocatedModules() { + return this.getObject(ModuleData, OnRCStatus.KEY_ALLOCATED_MODULES); + } + /** + * @param {ModuleData[]} modules - Contains a list (zero or more) of module types that are free to access for the + * application. + * @return {OnRCStatus} + */ + + + setFreeModules(modules) { + this.validateType(ModuleData, modules, true); + this.setParameter(OnRCStatus.KEY_FREE_MODULES, modules); + return this; + } + /** + * @return {ModuleData[]} + */ + + + getFreeModules() { + return this.getObject(ModuleData, OnRCStatus.KEY_FREE_MODULES); + } + + } + + OnRCStatus.KEY_ALLOWED = 'allowed'; + OnRCStatus.KEY_ALLOCATED_MODULES = 'allocatedModules'; + OnRCStatus.KEY_FREE_MODULES = 'freeModules'; + + /* eslint-disable camelcase */ + /** + * This notification includes the data that is updated from the specific service + */ + + class OnAppServiceData extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnAppServiceData); + } + /** + * @param {AppServiceData} data - Contains all the current data of the app service. The serviceType will link to + * which of the service data objects are included in this object (e.g. if the service + * type is MEDIA, the mediaServiceData param should be included). + * @return {OnAppServiceData} + */ + + + setServiceData(data) { + this.validateType(AppServiceData, data); + this.setParameter(OnAppServiceData.KEY_SERVICE_DATA, data); + return this; + } + /** + * @return {AppServiceData} + */ + + + getServiceData() { + return this.getObject(AppServiceData, OnAppServiceData.KEY_SERVICE_DATA); + } + + } + + OnAppServiceData.KEY_SERVICE_DATA = 'serviceData'; + + /* eslint-disable camelcase */ + /** + * A notification to inform the connected device that a specific system capability has changed. + */ + + class OnSystemCapabilityUpdated extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnSystemCapabilityUpdated); + } + /** + * @param {SystemCapability} capability - The system capability that has been updated + * @return {OnSystemCapabilityUpdated} + */ + + + setSystemCapability(capability) { + this.validateType(SystemCapability, capability); + this.setParameter(OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY, capability); + return this; + } + /** + * @return {SystemCapability} + */ + + + getSystemCapability() { + return this.getObject(SystemCapability, OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY); + } + + } + + OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY = 'systemCapability'; + + /* eslint-disable camelcase */ + /** + * Allows encoded data in the form of SyncP packets to be sent to the SYNC module. Legacy / v1 Protocol implementation; + * use SyncPData instead. *** DEPRECATED *** + */ + + class EncodedSyncPData extends RpcRequest { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.EncodedSyncPData); + } + /** + * @param {String[]} data - Contains base64 encoded string of SyncP packets. + * @return {EncodedSyncPData} + */ + + + setData(data) { + this.setParameter(EncodedSyncPData.KEY_DATA, data); + return this; + } + /** + * @return {String[]} + */ + + + getData() { + return this.getParameter(EncodedSyncPData.KEY_DATA); + } + + } + + EncodedSyncPData.KEY_DATA = 'data'; + + /* eslint-disable camelcase */ + + class EncodedSyncPDataResponse extends RpcResponse { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.EncodedSyncPData); + } + + } + + /* eslint-disable camelcase */ + /** + * Callback including encoded data of any SyncP packets that SYNC needs to send back to the mobile device. Legacy / v1 + * Protocol implementation; responds to EncodedSyncPData. *** DEPRECATED *** + */ + + class OnEncodedSyncPData extends RpcNotification { + /** + * @constructor + */ + constructor(store) { + super(store); + this.setFunctionName(FunctionID.OnEncodedSyncPData); + } + /** + * @param {String[]} data - Contains base64 encoded string of SyncP packets. + * @return {OnEncodedSyncPData} + */ + + + setData(data) { + this.setParameter(OnEncodedSyncPData.KEY_DATA, data); + return this; + } + /** + * @return {String[]} + */ + + + getData() { + return this.getParameter(OnEncodedSyncPData.KEY_DATA); + } + /** + * @param {String} url - If blank, the SyncP data shall be forwarded to the app. If not blank, the SyncP data shall + * be forwarded to the provided URL. + * @return {OnEncodedSyncPData} + */ + + + setURL(url) { + this.setParameter(OnEncodedSyncPData.KEY_URL, url); + return this; + } + /** + * @return {String} + */ + + + getURL() { + return this.getParameter(OnEncodedSyncPData.KEY_URL); + } + /** + * @param {Number} timeout - If blank, the SyncP data shall be forwarded to the app. If not blank, the SyncP data + * shall be forwarded with the provided timeout in seconds. + * @return {OnEncodedSyncPData} + */ + + + setTimeout(timeout) { + this.setParameter(OnEncodedSyncPData.KEY_TIMEOUT, timeout); + return this; + } + /** + * @return {Number} + */ + + + getTimeout() { + return this.getParameter(OnEncodedSyncPData.KEY_TIMEOUT); + } + + } + + OnEncodedSyncPData.KEY_DATA = 'data'; + OnEncodedSyncPData.KEY_URL = 'URL'; + OnEncodedSyncPData.KEY_TIMEOUT = 'Timeout'; + + /* eslint-disable camelcase */ + + class RpcCreator { + /** + * Converts an SdlPacket to an RpcMessage + * @param {SdlPacket} sdlPacket + * @return {RpcMessage} + */ + static construct(sdlPacket) { + const payload = sdlPacket.getPayload(); + const binaryFrameHeader = BinaryFrameHeader.fromBinaryHeader(payload); + let message; + const rpcType = binaryFrameHeader.getRpcType(); + const rpcName = RpcType.keyForValue(rpcType); + const correlationId = binaryFrameHeader.getCorrelationId(); + const functionId = binaryFrameHeader.getFunctionId(); + const functionName = FunctionID.keyForValue(functionId); + const bulkData = binaryFrameHeader.getBulkData(); + const jsonData = binaryFrameHeader.getJsonData(); + const params = { + parameters: JsonRpcMarshaller.unmarshall(jsonData) + }; + + switch (functionId) { + case FunctionID.RegisterAppInterface: + if (rpcType === RpcType.REQUEST) { + message = new RegisterAppInterface(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new RegisterAppInterfaceResponse(params); + } + + break; + + case FunctionID.UnregisterAppInterface: + if (rpcType === RpcType.REQUEST) { + message = new UnregisterAppInterface(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new UnregisterAppInterfaceResponse(params); + } + + break; + + case FunctionID.CreateWindow: + if (rpcType === RpcType.REQUEST) { + message = new CreateWindow(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new CreateWindowResponse(params); + } + + break; + + case FunctionID.DeleteWindow: + if (rpcType === RpcType.REQUEST) { + message = new DeleteWindow(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new DeleteWindowResponse(params); + } + + break; + + case FunctionID.SetGlobalProperties: + if (rpcType === RpcType.REQUEST) { + message = new SetGlobalProperties(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SetGlobalPropertiesResponse(params); + } + + break; + + case FunctionID.ResetGlobalProperties: + if (rpcType === RpcType.REQUEST) { + message = new ResetGlobalProperties(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ResetGlobalPropertiesResponse(params); + } + + break; + + case FunctionID.AddCommand: + if (rpcType === RpcType.REQUEST) { + message = new AddCommand(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new AddCommandResponse(params); + } + + break; + + case FunctionID.DeleteCommand: + if (rpcType === RpcType.REQUEST) { + message = new DeleteCommand(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new DeleteCommandResponse(params); + } + + break; + + case FunctionID.AddSubMenu: + if (rpcType === RpcType.REQUEST) { + message = new AddSubMenu(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new AddSubMenuResponse(params); + } + + break; + + case FunctionID.DeleteSubMenu: + if (rpcType === RpcType.REQUEST) { + message = new DeleteSubMenu(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new DeleteSubMenuResponse(params); + } + + break; + + case FunctionID.ShowAppMenu: + if (rpcType === RpcType.REQUEST) { + message = new ShowAppMenu(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ShowAppMenuResponse(params); + } + + break; + + case FunctionID.CreateInteractionChoiceSet: + if (rpcType === RpcType.REQUEST) { + message = new CreateInteractionChoiceSet(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new CreateInteractionChoiceSetResponse(params); + } + + break; + + case FunctionID.PerformInteraction: + if (rpcType === RpcType.REQUEST) { + message = new PerformInteraction(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new PerformInteractionResponse(params); + } + + break; + + case FunctionID.DeleteInteractionChoiceSet: + if (rpcType === RpcType.REQUEST) { + message = new DeleteInteractionChoiceSet(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new DeleteInteractionChoiceSetResponse(params); + } + + break; + + case FunctionID.Alert: + if (rpcType === RpcType.REQUEST) { + message = new Alert(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new AlertResponse(params); + } + + break; + + case FunctionID.Show: + if (rpcType === RpcType.REQUEST) { + message = new Show(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ShowResponse(params); + } + + break; + + case FunctionID.Speak: + if (rpcType === RpcType.REQUEST) { + message = new Speak(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SpeakResponse(params); + } + + break; + + case FunctionID.SetMediaClockTimer: + if (rpcType === RpcType.REQUEST) { + message = new SetMediaClockTimer(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SetMediaClockTimerResponse(params); + } + + break; + + case FunctionID.PerformAudioPassThru: + if (rpcType === RpcType.REQUEST) { + message = new PerformAudioPassThru(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new PerformAudioPassThruResponse(params); + } + + break; + + case FunctionID.EndAudioPassThru: + if (rpcType === RpcType.REQUEST) { + message = new EndAudioPassThru(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new EndAudioPassThruResponse(params); + } + + break; + + case FunctionID.SubscribeButton: + if (rpcType === RpcType.REQUEST) { + message = new SubscribeButton(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SubscribeButtonResponse(params); + } + + break; + + case FunctionID.UnsubscribeButton: + if (rpcType === RpcType.REQUEST) { + message = new UnsubscribeButton(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new UnsubscribeButtonResponse(params); + } + + break; + + case FunctionID.SubscribeVehicleData: + if (rpcType === RpcType.REQUEST) { + message = new SubscribeVehicleData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SubscribeVehicleDataResponse(params); + } + + break; + + case FunctionID.UnsubscribeVehicleData: + if (rpcType === RpcType.REQUEST) { + message = new UnsubscribeVehicleData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new UnsubscribeVehicleDataResponse(params); + } + + break; + + case FunctionID.GetVehicleData: + if (rpcType === RpcType.REQUEST) { + message = new GetVehicleData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetVehicleDataResponse(params); + } + + break; + + case FunctionID.ReadDID: + if (rpcType === RpcType.REQUEST) { + message = new ReadDID(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ReadDIDResponse(params); + } + + break; + + case FunctionID.GetDTCs: + if (rpcType === RpcType.REQUEST) { + message = new GetDTCs(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetDTCsResponse(params); + } + + break; + + case FunctionID.DiagnosticMessage: + if (rpcType === RpcType.REQUEST) { + message = new DiagnosticMessage(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new DiagnosticMessageResponse(params); + } + + break; + + case FunctionID.ScrollableMessage: + if (rpcType === RpcType.REQUEST) { + message = new ScrollableMessage(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ScrollableMessageResponse(params); + } + + break; + + case FunctionID.Slider: + if (rpcType === RpcType.REQUEST) { + message = new Slider(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SliderResponse(params); + } + + break; + + case FunctionID.ShowConstantTBT: + if (rpcType === RpcType.REQUEST) { + message = new ShowConstantTBT(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ShowConstantTBTResponse(params); + } + + break; + + case FunctionID.AlertManeuver: + if (rpcType === RpcType.REQUEST) { + message = new AlertManeuver(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new AlertManeuverResponse(params); + } + + break; + + case FunctionID.UpdateTurnList: + if (rpcType === RpcType.REQUEST) { + message = new UpdateTurnList(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new UpdateTurnListResponse(params); + } + + break; + + case FunctionID.ChangeRegistration: + if (rpcType === RpcType.REQUEST) { + message = new ChangeRegistration(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ChangeRegistrationResponse(params); + } + + break; + + case FunctionID.GenericResponse: + if (rpcType === RpcType.RESPONSE) { + message = new GenericResponseResponse(params); + } + + break; + + case FunctionID.PutFile: + if (rpcType === RpcType.REQUEST) { + message = new PutFile(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new PutFileResponse(params); + } + + break; + + case FunctionID.GetFile: + if (rpcType === RpcType.REQUEST) { + message = new GetFile(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetFileResponse(params); + } + + break; + + case FunctionID.DeleteFile: + if (rpcType === RpcType.REQUEST) { + message = new DeleteFile(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new DeleteFileResponse(params); + } + + break; + + case FunctionID.ListFiles: + if (rpcType === RpcType.REQUEST) { + message = new ListFiles(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ListFilesResponse(params); + } + + break; + + case FunctionID.SetAppIcon: + if (rpcType === RpcType.REQUEST) { + message = new SetAppIcon(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SetAppIconResponse(params); + } + + break; + + case FunctionID.SetDisplayLayout: + if (rpcType === RpcType.REQUEST) { + message = new SetDisplayLayout(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SetDisplayLayoutResponse(params); + } + + break; + + case FunctionID.SystemRequest: + if (rpcType === RpcType.REQUEST) { + message = new SystemRequest(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SystemRequestResponse(params); + } + + break; + + case FunctionID.SendLocation: + if (rpcType === RpcType.REQUEST) { + message = new SendLocation(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SendLocationResponse(params); + } + + break; + + case FunctionID.DialNumber: + if (rpcType === RpcType.REQUEST) { + message = new DialNumber(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new DialNumberResponse(params); + } + + break; + + case FunctionID.ButtonPress: + if (rpcType === RpcType.REQUEST) { + message = new ButtonPress(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ButtonPressResponse(params); + } + + break; + + case FunctionID.GetInteriorVehicleData: + if (rpcType === RpcType.REQUEST) { + message = new GetInteriorVehicleData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetInteriorVehicleDataResponse(params); + } + + break; + + case FunctionID.GetInteriorVehicleDataConsent: + if (rpcType === RpcType.REQUEST) { + message = new GetInteriorVehicleDataConsent(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetInteriorVehicleDataConsentResponse(params); + } + + break; + + case FunctionID.ReleaseInteriorVehicleDataModule: + if (rpcType === RpcType.REQUEST) { + message = new ReleaseInteriorVehicleDataModule(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new ReleaseInteriorVehicleDataModuleResponse(params); + } + + break; + + case FunctionID.SetInteriorVehicleData: + if (rpcType === RpcType.REQUEST) { + message = new SetInteriorVehicleData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SetInteriorVehicleDataResponse(params); + } + + break; + + case FunctionID.SubscribeWayPoints: + if (rpcType === RpcType.REQUEST) { + message = new SubscribeWayPoints(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SubscribeWayPointsResponse(params); + } + + break; + + case FunctionID.GetWayPoints: + if (rpcType === RpcType.REQUEST) { + message = new GetWayPoints(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetWayPointsResponse(params); + } + + break; + + case FunctionID.UnsubscribeWayPoints: + if (rpcType === RpcType.REQUEST) { + message = new UnsubscribeWayPoints(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new UnsubscribeWayPointsResponse(params); + } + + break; + + case FunctionID.GetSystemCapability: + if (rpcType === RpcType.REQUEST) { + message = new GetSystemCapability(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetSystemCapabilityResponse(params); + } + + break; + + case FunctionID.SendHapticData: + if (rpcType === RpcType.REQUEST) { + message = new SendHapticData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SendHapticDataResponse(params); + } + + break; + + case FunctionID.SetCloudAppProperties: + if (rpcType === RpcType.REQUEST) { + message = new SetCloudAppProperties(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new SetCloudAppPropertiesResponse(params); + } + + break; + + case FunctionID.GetCloudAppProperties: + if (rpcType === RpcType.REQUEST) { + message = new GetCloudAppProperties(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetCloudAppPropertiesResponse(params); + } + + break; + + case FunctionID.PublishAppService: + if (rpcType === RpcType.REQUEST) { + message = new PublishAppService(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new PublishAppServiceResponse(params); + } + + break; + + case FunctionID.UnpublishAppService: + if (rpcType === RpcType.REQUEST) { + message = new UnpublishAppService(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new UnpublishAppServiceResponse(params); + } + + break; + + case FunctionID.GetAppServiceData: + if (rpcType === RpcType.REQUEST) { + message = new GetAppServiceData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new GetAppServiceDataResponse(params); + } + + break; + + case FunctionID.PerformAppServiceInteraction: + if (rpcType === RpcType.REQUEST) { + message = new PerformAppServiceInteraction(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new PerformAppServiceInteractionResponse(params); + } + + break; + + case FunctionID.CancelInteraction: + if (rpcType === RpcType.REQUEST) { + message = new CancelInteraction(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new CancelInteractionResponse(params); + } + + break; + + case FunctionID.CloseApplication: + if (rpcType === RpcType.REQUEST) { + message = new CloseApplication(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new CloseApplicationResponse(params); + } + + break; + + case FunctionID.OnHMIStatus: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnHMIStatus(params); + } + + break; + + case FunctionID.OnAppInterfaceUnregistered: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnAppInterfaceUnregistered(params); + } + + break; + + case FunctionID.OnButtonEvent: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnButtonEvent(params); + } + + break; + + case FunctionID.OnButtonPress: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnButtonPress(params); + } + + break; + + case FunctionID.OnVehicleData: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnVehicleData(params); + } + + break; + + case FunctionID.OnCommand: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnCommand(params); + } + + break; + + case FunctionID.OnTBTClientState: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnTBTClientState(params); + } + + break; + + case FunctionID.OnDriverDistraction: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnDriverDistraction(params); + } + + break; + + case FunctionID.OnPermissionsChange: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnPermissionsChange(params); + } + + break; + + case FunctionID.OnAudioPassThru: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnAudioPassThru(params); + } + + break; + + case FunctionID.OnLanguageChange: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnLanguageChange(params); + } + + break; + + case FunctionID.OnKeyboardInput: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnKeyboardInput(params); + } + + break; + + case FunctionID.OnTouchEvent: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnTouchEvent(params); + } + + break; + + case FunctionID.OnSystemRequest: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnSystemRequest(params); + } + + break; + + case FunctionID.OnHashChange: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnHashChange(params); + } + + break; + + case FunctionID.OnWayPointChange: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnWayPointChange(params); + } + + break; + + case FunctionID.OnInteriorVehicleData: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnInteriorVehicleData(params); + } + + break; + + case FunctionID.OnRCStatus: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnRCStatus(params); + } + + break; + + case FunctionID.OnAppServiceData: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnAppServiceData(params); + } + + break; + + case FunctionID.OnSystemCapabilityUpdated: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnSystemCapabilityUpdated(params); + } + + break; + + case FunctionID.EncodedSyncPData: + if (rpcType === RpcType.REQUEST) { + message = new EncodedSyncPData(params); + } else if (rpcType === RpcType.RESPONSE) { + message = new EncodedSyncPDataResponse(params); + } + + break; + + case FunctionID.OnEncodedSyncPData: + if (rpcType === RpcType.NOTIFICATION) { + message = new OnEncodedSyncPData(params); + } + + break; + + default: + message = null; + } + + if (message === null || message === undefined) { + // informs of missing classes + console.warn(`RpcCreator couldn't construct an RPC for the ${functionName} ${rpcName}`); + return null; + } + + if (rpcType === RpcType.REQUEST || rpcType === RpcType.RESPONSE) { + message.setCorrelationId(correlationId); + } + + if (bulkData) { + message.setBulkData(bulkData); + } + + return message; + } + + } + /* * Copyright (c) 2019, Livio, Inc. * All rights reserved. @@ -28087,7 +54839,7 @@ _createRegisterAppInterface() { const registerAppInterface = new RegisterAppInterface(); - registerAppInterface.setSdlMsgVersion(new SdlMsgVersion().setMajorVersion(LifecycleManager.MAX_RPC_VERSION.getMajor()).setMinorVersion(LifecycleManager.MAX_RPC_VERSION.getMinor()).setPatchVersion(LifecycleManager.MAX_RPC_VERSION.getPatch())).setAppName(this._appConfig.getAppName()).setFullAppId(this._appConfig.getAppId()).setNgnMediaScreenAppName(this._appConfig.getShortAppName()).setAppHmiType(this._appConfig.getAppTypes()).setLanguageDesired(this._appConfig.getLanguageDesired()).setHmiDisplayLanguageDesired(this._appConfig.getHmiDisplayLanguageDesired()).setIsMediaApplication(this._appConfig.isMediaApp()).setDayColorScheme(this._appConfig.getDayColorScheme()).setNightColorScheme(this._appConfig.getNightColorScheme()).setCorrelationId(LifecycleManager.REGISTER_APP_INTERFACE_CORRELATION_ID); // TODO Add all possible items + registerAppInterface.setSdlMsgVersion(new SdlMsgVersion().setMajorVersion(LifecycleManager.MAX_RPC_VERSION.getMajor()).setMinorVersion(LifecycleManager.MAX_RPC_VERSION.getMinor()).setPatchVersion(LifecycleManager.MAX_RPC_VERSION.getPatch())).setAppName(this._appConfig.getAppName()).setFullAppId(this._appConfig.getAppId()).setNgnMediaScreenAppName(this._appConfig.getShortAppName()).setAppHMIType(this._appConfig.getAppTypes()).setLanguageDesired(this._appConfig.getLanguageDesired()).setHmiDisplayLanguageDesired(this._appConfig.getHmiDisplayLanguageDesired()).setIsMediaApplication(this._appConfig.isMediaApp()).setDayColorScheme(this._appConfig.getDayColorScheme()).setNightColorScheme(this._appConfig.getNightColorScheme()).setCorrelationId(LifecycleManager.REGISTER_APP_INTERFACE_CORRELATION_ID); // TODO Add all possible items return registerAppInterface; } @@ -28109,8 +54861,8 @@ case FunctionID.OnHMIStatus: { // send a single onProxyConnected, when we go from a null HMI level to a defined HMI level - const shouldInit = rpcMessage.getHMILevel() !== null && rpcMessage.getHMILevel() !== undefined && this._currentHMIStatus === null; - this._currentHMIStatus = rpcMessage.getHMILevel(); + const shouldInit = rpcMessage.getHmiLevel() !== null && rpcMessage.getHmiLevel() !== undefined && this._currentHMIStatus === null; + this._currentHMIStatus = rpcMessage.getHmiLevel(); if (this._lifecycleListener !== null && this._lifecycleListener !== undefined && shouldInit) { this._lifecycleListener.onProxyConnected(this); @@ -28153,182 +54905,747 @@ LifecycleManager.REGISTER_APP_INTERFACE_CORRELATION_ID = 65529; LifecycleManager.UNREGISTER_APP_INTERFACE_CORRELATION_ID = 65530; - /* - * Copyright (c) 2019, Livio, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following - * disclaimer in the documentation and/or other materials provided with the - * distribution. - * - * Neither the name of the Livio Inc. nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ + /* eslint-disable camelcase */ + /** + * @typedef {Enum} AppServiceType + * @property {Object} _MAP + */ - class VideoStreamingCapability extends RpcStruct { + class AppServiceType extends Enum { /** - * @constructor - */ + * @constructor + */ constructor() { super(); } /** - * @param {ImageResolution} val - * @return {VideoStreamingCapability} - */ + * @return {String} + */ - setPreferredResolution(val) { - this.validateType(ImageResolution, val); - this.setParameter(VideoStreamingCapability.KEY_PREFERRED_RESOLUTION, val); - return this; + static get MEDIA() { + return AppServiceType._MAP.MEDIA; } /** - * @return {ImageResolution} - */ + * @return {String} + */ - getPreferredResolution() { - return this.getObject(ImageResolution, VideoStreamingCapability.KEY_PREFERRED_RESOLUTION); + static get WEATHER() { + return AppServiceType._MAP.WEATHER; } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ + * @return {String} + */ - setMaxBitrate(val) { - this.setParameter(VideoStreamingCapability.KEY_MAX_BITRATE, val); - return this; + static get NAVIGATION() { + return AppServiceType._MAP.NAVIGATION; } /** - * @return {number} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - getMaxBitrate() { - return this.getParameter(VideoStreamingCapability.KEY_MAX_BITRATE); + static valueForKey(key) { + return AppServiceType._valueForKey(key, AppServiceType._MAP); } /** - * @param {VideoStreamingFormat[]} val - * @return {VideoStreamingCapability} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - setSupportedFormats(val) { - this.validateType(VideoStreamingFormat, val, true); - this.setParameter(VideoStreamingCapability.KEY_SUPPORTED_FORMATS, val); + static keyForValue(value) { + return AppServiceType._keyForValue(value, AppServiceType._MAP); } + + } + + AppServiceType._MAP = Object.freeze({ + 'MEDIA': 'MEDIA', + 'WEATHER': 'WEATHER', + 'NAVIGATION': 'NAVIGATION' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of a vehicle maintenance mode. + * @typedef {Enum} MaintenanceModeStatus + * @property {Object} _MAP + */ + + class MaintenanceModeStatus extends Enum { /** - * @return {VideoStreamingFormat[]} - */ + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ - getSupportedFormats() { - return this.getObject(VideoStreamingFormat, VideoStreamingCapability.KEY_SUPPORTED_FORMATS); + static get MMS_NORMAL() { + return MaintenanceModeStatus._MAP.MMS_NORMAL; } /** - * @param {Boolean} val - * @return {VideoStreamingCapability} - */ + * @return {String} + */ - setHapticSpatialDataSupported(val) { - this.setParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED, val); - return this; + static get MMS_NEAR() { + return MaintenanceModeStatus._MAP.MMS_NEAR; } /** - * @return {Boolean} - */ + * @return {String} + */ - getHapticSpatialDataSupported() { - return this.getParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED); + static get MMS_ACTIVE() { + return MaintenanceModeStatus._MAP.MMS_ACTIVE; } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ + * @return {String} + */ - setDiagonalScreenSize(val) { - this.setParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE, val); - return this; + static get MMS_FEATURE_NOT_PRESENT() { + return MaintenanceModeStatus._MAP.MMS_FEATURE_NOT_PRESENT; } /** - * @return {number} - */ + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ - getDiagonalScreenSize() { - return this.getParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE); + static valueForKey(key) { + return MaintenanceModeStatus._valueForKey(key, MaintenanceModeStatus._MAP); } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ - setPixelPerInch(val) { - this.setParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH, val); - return this; + static keyForValue(value) { + return MaintenanceModeStatus._keyForValue(value, MaintenanceModeStatus._MAP); } + + } + + MaintenanceModeStatus._MAP = Object.freeze({ + 'MMS_NORMAL': 'NORMAL', + 'MMS_NEAR': 'NEAR', + 'MMS_ACTIVE': 'ACTIVE', + 'MMS_FEATURE_NOT_PRESENT': 'FEATURE_NOT_PRESENT' + }); + + /* eslint-disable camelcase */ + /** + * Enumeration that describes possible permission states of a policy table entry. + * @typedef {Enum} PermissionStatus + * @property {Object} _MAP + */ + + class PermissionStatus extends Enum { /** - * @return {number} - */ + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ - getPixelPerInch() { - return this.getParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH); + static get PS_ALLOWED() { + return PermissionStatus._MAP.PS_ALLOWED; } /** - * @param {number} val - * @return {VideoStreamingCapability} - */ + * @return {String} + */ - setScale(val) { - this.setParameter(VideoStreamingCapability.KEY_SCALE, val); - return this; + static get PS_DISALLOWED() { + return PermissionStatus._MAP.PS_DISALLOWED; } /** - * @return {number} - */ + * @return {String} + */ - getScale() { - return this.getParameter(VideoStreamingCapability.KEY_SCALE); + static get PS_USER_DISALLOWED() { + return PermissionStatus._MAP.PS_USER_DISALLOWED; + } + /** + * @return {String} + */ + + + static get PS_USER_CONSENT_PENDING() { + return PermissionStatus._MAP.PS_USER_CONSENT_PENDING; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return PermissionStatus._valueForKey(key, PermissionStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PermissionStatus._keyForValue(value, PermissionStatus._MAP); } } - VideoStreamingCapability.KEY_PREFERRED_RESOLUTION = 'preferredResolution'; - VideoStreamingCapability.KEY_MAX_BITRATE = 'maxBitrate'; - VideoStreamingCapability.KEY_SUPPORTED_FORMATS = 'supportedFormats'; - VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED = 'hapticSpatialDataSupported'; - VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE = 'diagonalScreenSize'; - VideoStreamingCapability.KEY_PIXEL_PER_INCH = 'pixelPerInch'; - VideoStreamingCapability.KEY_SCALE = 'scale'; + PermissionStatus._MAP = Object.freeze({ + 'PS_ALLOWED': 'ALLOWED', + 'PS_DISALLOWED': 'DISALLOWED', + 'PS_USER_DISALLOWED': 'USER_DISALLOWED', + 'PS_USER_CONSENT_PENDING': 'USER_CONSENT_PENDING' + }); + + /* eslint-disable camelcase */ + /** + * Predefined screen layout. + * @typedef {Enum} PredefinedLayout + * @property {Object} _MAP + */ + + class PredefinedLayout extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Default media / non-media screen. Can be set as a root screen. + * @return {String} + */ + + + static get DEFAULT() { + return PredefinedLayout._MAP.DEFAULT; + } + /** + * Default Media screen. Can be set as a root screen. + * @return {String} + */ + + + static get MEDIA() { + return PredefinedLayout._MAP.MEDIA; + } + /** + * Default Non-media screen. Can be set as a root screen. + * @return {String} + */ + + + static get NON_MEDIA() { + return PredefinedLayout._MAP.NON_MEDIA; + } + /** + * Custom root media screen containing app-defined onscreen presets. Can be set as a root screen. + * @return {String} + */ + + + static get ONSCREEN_PRESETS() { + return PredefinedLayout._MAP.ONSCREEN_PRESETS; + } + /** + * Custom root template screen containing full screen map with navigation controls. Can be set as a root screen. + * @return {String} + */ + + + static get NAV_FULLSCREEN_MAP() { + return PredefinedLayout._MAP.NAV_FULLSCREEN_MAP; + } + /** + * Custom root template screen containing video represented list. Can be set as a root screen. + * @return {String} + */ + + + static get NAV_LIST() { + return PredefinedLayout._MAP.NAV_LIST; + } + /** + * Custom root template screen containing video represented keyboard. Can be set as a root screen. + * @return {String} + */ + + + static get NAV_KEYBOARD() { + return PredefinedLayout._MAP.NAV_KEYBOARD; + } + /** + * Custom root template screen containing half-screen graphic with lines of text. Can be set as a root screen. + * @return {String} + */ + + + static get GRAPHIC_WITH_TEXT() { + return PredefinedLayout._MAP.GRAPHIC_WITH_TEXT; + } + /** + * Custom root template screen containing lines of text with half-screen graphic. Can be set as a root screen. + * @return {String} + */ + + + static get TEXT_WITH_GRAPHIC() { + return PredefinedLayout._MAP.TEXT_WITH_GRAPHIC; + } + /** + * Custom root template screen containing only tiled SoftButtons. Can be set as a root screen. + * @return {String} + */ + + + static get TILES_ONLY() { + return PredefinedLayout._MAP.TILES_ONLY; + } + /** + * Custom root template screen containing only text SoftButtons. Can be set as a root screen. + * @return {String} + */ + + + static get TEXTBUTTONS_ONLY() { + return PredefinedLayout._MAP.TEXTBUTTONS_ONLY; + } + /** + * Custom root template screen containing half-screen graphic with tiled SoftButtons. Can be set as a root screen. + * @return {String} + */ + + + static get GRAPHIC_WITH_TILES() { + return PredefinedLayout._MAP.GRAPHIC_WITH_TILES; + } + /** + * Custom root template screen containing tiled SoftButtons with half-screen graphic. Can be set as a root screen. + * @return {String} + */ + + + static get TILES_WITH_GRAPHIC() { + return PredefinedLayout._MAP.TILES_WITH_GRAPHIC; + } + /** + * Custom root template screen containing half-screen graphic with text and SoftButtons. Can be set as a root + * screen. + * @return {String} + */ + + + static get GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS() { + return PredefinedLayout._MAP.GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS; + } + /** + * Custom root template screen containing text and SoftButtons with half-screen graphic. Can be set as a root + * screen. + * @return {String} + */ + + + static get TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC() { + return PredefinedLayout._MAP.TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC; + } + /** + * Custom root template screen containing half-screen graphic with text only SoftButtons. Can be set as a root + * screen. + * @return {String} + */ + + + static get GRAPHIC_WITH_TEXTBUTTONS() { + return PredefinedLayout._MAP.GRAPHIC_WITH_TEXTBUTTONS; + } + /** + * Custom root template screen containing text only SoftButtons with half-screen graphic. Can be set as a root + * screen. + * @return {String} + */ + + + static get TEXTBUTTONS_WITH_GRAPHIC() { + return PredefinedLayout._MAP.TEXTBUTTONS_WITH_GRAPHIC; + } + /** + * Custom root template screen containing a large graphic and SoftButtons. Can be set as a root screen. + * @return {String} + */ + + + static get LARGE_GRAPHIC_WITH_SOFTBUTTONS() { + return PredefinedLayout._MAP.LARGE_GRAPHIC_WITH_SOFTBUTTONS; + } + /** + * Custom root template screen containing two graphics and SoftButtons. Can be set as a root screen. + * @return {String} + */ + + + static get DOUBLE_GRAPHIC_WITH_SOFTBUTTONS() { + return PredefinedLayout._MAP.DOUBLE_GRAPHIC_WITH_SOFTBUTTONS; + } + /** + * Custom root template screen containing only a large graphic. Can be set as a root screen. + * @return {String} + */ + + + static get LARGE_GRAPHIC_ONLY() { + return PredefinedLayout._MAP.LARGE_GRAPHIC_ONLY; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return PredefinedLayout._valueForKey(key, PredefinedLayout._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PredefinedLayout._keyForValue(value, PredefinedLayout._MAP); + } + + } + + PredefinedLayout._MAP = Object.freeze({ + 'DEFAULT': 'DEFAULT', + 'MEDIA': 'MEDIA', + 'NON_MEDIA': 'NON-MEDIA', + 'ONSCREEN_PRESETS': 'ONSCREEN_PRESETS', + 'NAV_FULLSCREEN_MAP': 'NAV_FULLSCREEN_MAP', + 'NAV_LIST': 'NAV_LIST', + 'NAV_KEYBOARD': 'NAV_KEYBOARD', + 'GRAPHIC_WITH_TEXT': 'GRAPHIC_WITH_TEXT', + 'TEXT_WITH_GRAPHIC': 'TEXT_WITH_GRAPHIC', + 'TILES_ONLY': 'TILES_ONLY', + 'TEXTBUTTONS_ONLY': 'TEXTBUTTONS_ONLY', + 'GRAPHIC_WITH_TILES': 'GRAPHIC_WITH_TILES', + 'TILES_WITH_GRAPHIC': 'TILES_WITH_GRAPHIC', + 'GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS': 'GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS', + 'TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC': 'TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC', + 'GRAPHIC_WITH_TEXTBUTTONS': 'GRAPHIC_WITH_TEXTBUTTONS', + 'TEXTBUTTONS_WITH_GRAPHIC': 'TEXTBUTTONS_WITH_GRAPHIC', + 'LARGE_GRAPHIC_WITH_SOFTBUTTONS': 'LARGE_GRAPHIC_WITH_SOFTBUTTONS', + 'DOUBLE_GRAPHIC_WITH_SOFTBUTTONS': 'DOUBLE_GRAPHIC_WITH_SOFTBUTTONS', + 'LARGE_GRAPHIC_ONLY': 'LARGE_GRAPHIC_ONLY' + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} PredefinedWindows + * @property {Object} _MAP + */ + + class PredefinedWindows extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * The default window is a main window pre-created on behalf of the app. + * @return {Number} + */ + + + static get DEFAULT_WINDOW() { + return PredefinedWindows._MAP.DEFAULT_WINDOW; + } + /** + * The primary widget of the app. + * @return {Number} + */ + + + static get PRIMARY_WIDGET() { + return PredefinedWindows._MAP.PRIMARY_WIDGET; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return PredefinedWindows._valueForKey(key, PredefinedWindows._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return PredefinedWindows._keyForValue(value, PredefinedWindows._MAP); + } + + } + + PredefinedWindows._MAP = Object.freeze({ + 'DEFAULT_WINDOW': 0, + 'PRIMARY_WIDGET': 1 + }); + + /* eslint-disable camelcase */ + /** + * @typedef {Enum} TimerMode + * @property {Object} _MAP + */ + + class TimerMode extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * Causes the media clock timer to update from 0:00 to a specified time + * @return {String} + */ + + + static get UP() { + return TimerMode._MAP.UP; + } + /** + * Causes the media clock timer to update from a specified time to 0:00 + * @return {String} + */ + + + static get DOWN() { + return TimerMode._MAP.DOWN; + } + /** + * Indicates to not use the media clock timer + * @return {String} + */ + + + static get NONE() { + return TimerMode._MAP.NONE; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return TimerMode._valueForKey(key, TimerMode._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return TimerMode._keyForValue(value, TimerMode._MAP); + } + + } + + TimerMode._MAP = Object.freeze({ + 'UP': 'UP', + 'DOWN': 'DOWN', + 'NONE': 'NONE' + }); + + /* eslint-disable camelcase */ + /** + * Reflects the status of given vehicle component. + * @typedef {Enum} VehicleDataActiveStatus + * @property {Object} _MAP + */ + + class VehicleDataActiveStatus extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {String} + */ + + + static get VDAS_INACTIVE_NOT_CONFIRMED() { + return VehicleDataActiveStatus._MAP.VDAS_INACTIVE_NOT_CONFIRMED; + } + /** + * @return {String} + */ + + + static get VDAS_INACTIVE_CONFIRMED() { + return VehicleDataActiveStatus._MAP.VDAS_INACTIVE_CONFIRMED; + } + /** + * @return {String} + */ + + + static get VDAS_ACTIVE_NOT_CONFIRMED() { + return VehicleDataActiveStatus._MAP.VDAS_ACTIVE_NOT_CONFIRMED; + } + /** + * @return {String} + */ + + + static get VDAS_ACTIVE_CONFIRMED() { + return VehicleDataActiveStatus._MAP.VDAS_ACTIVE_CONFIRMED; + } + /** + * @return {String} + */ + + + static get VDAS_FAULT() { + return VehicleDataActiveStatus._MAP.VDAS_FAULT; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return VehicleDataActiveStatus._valueForKey(key, VehicleDataActiveStatus._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return VehicleDataActiveStatus._keyForValue(value, VehicleDataActiveStatus._MAP); + } + + } + + VehicleDataActiveStatus._MAP = Object.freeze({ + 'VDAS_INACTIVE_NOT_CONFIRMED': 'INACTIVE_NOT_CONFIRMED', + 'VDAS_INACTIVE_CONFIRMED': 'INACTIVE_CONFIRMED', + 'VDAS_ACTIVE_NOT_CONFIRMED': 'ACTIVE_NOT_CONFIRMED', + 'VDAS_ACTIVE_CONFIRMED': 'ACTIVE_CONFIRMED', + 'VDAS_FAULT': 'FAULT' + }); + + /* eslint-disable camelcase */ + /** + * Enumeration linking message types with function types in WiPro protocol. Assumes enumeration starts at value 0. + * @typedef {Enum} messageType + * @property {Object} _MAP + */ + + class messageType extends Enum { + /** + * @constructor + */ + constructor() { + super(); + } + /** + * @return {Number} + */ + + + static get request() { + return messageType._MAP.request; + } + /** + * @return {Number} + */ + + + static get response() { + return messageType._MAP.response; + } + /** + * @return {Number} + */ + + + static get notification() { + return messageType._MAP.notification; + } + /** + * Get the value for the given enum key + * @param key - A key to find in the map of the subclass + * @return {*} - Returns a value if found, or null if not found + */ + + + static valueForKey(key) { + return messageType._valueForKey(key, messageType._MAP); + } + /** + * Get the key for the given enum value + * @param value - A primitive value to find the matching key for in the map of the subclass + * @return {*} - Returns a key if found, or null if not found + */ + + + static keyForValue(value) { + return messageType._keyForValue(value, messageType._MAP); + } + + } + + messageType._MAP = Object.freeze({ + 'request': 0, + 'response': 1, + 'notification': 2 + }); /* * Copyright (c) 2019, Livio, Inc. @@ -29044,80 +56361,367 @@ RpcResponse, RpcStruct, enums: { + AmbientLightStatus, AppHMIType, + AppInterfaceUnregisteredReason, + AppServiceType, + AudioStreamingIndicator, AudioStreamingState, AudioType, BitsPerSample, + ButtonEventMode, ButtonName, + ButtonPressMode, + CarModeStatus, CharacterSet, + CompassDirection, + ComponentVolumeStatus, + DefrostZone, + DeliveryMode, + DeviceLevelStatus, + Dimension, + Direction, + DisplayMode, DisplayType, + DistanceUnit, + DriverDistractionState, + ECallConfirmationStatus, + ElectronicParkBrakeStatus, + EmergencyEventType, FileType, + FuelCutoffStatus, + FuelType, FunctionID, + GlobalProperty, HMILevel, HmiZoneCapabilities, + HybridAppPreference, + IgnitionStableStatus, + IgnitionStatus, ImageFieldName, ImageType, + InteractionMode, + KeyboardEvent, + KeyboardLayout, + KeypressMode, Language, + LayoutMode, + LightName, + LightStatus, + MaintenanceModeStatus, + MassageCushion, + MassageMode, + MassageZone, MediaClockFormat, + MediaType, + MenuLayout, MetadataType, + ModuleType, + NavigationAction, + NavigationJunction, + PRNDL, + PermissionStatus, + PowerModeQualificationStatus, + PowerModeStatus, + PredefinedLayout, + PredefinedWindows, PrerecordedSpeech, + PrimaryAudioSource, + RadioBand, + RadioState, + RequestType, Result, RpcType, SamplingRate, + SeatMemoryActionType, + ServiceUpdateReason, SoftButtonType, SpeechCapabilities, + SupportedSeat, SystemAction, + SystemCapabilityType, SystemContext, + TBTState, + TPMS, + TemperatureUnit, TextAlignment, TextFieldName, + TimerMode, + TouchType, + TriggerSource, + TurnSignal, + UpdateMode, + VehicleDataActiveStatus, + VehicleDataEventStatus, + VehicleDataNotificationStatus, + VehicleDataResultCode, + VehicleDataStatus, + VehicleDataType, + VentilationMode, VideoStreamingCodec, VideoStreamingProtocol, VideoStreamingState, - VrCapabilities + VrCapabilities, + WarningLightStatus, + WayPointType, + WindowType, + WiperStatus, + messageType }, messages: { AddCommand, AddCommandResponse, - OnHmiStatus, + AddSubMenu, + AddSubMenuResponse, + Alert, + AlertManeuver, + AlertManeuverResponse, + AlertResponse, + ButtonPress, + ButtonPressResponse, + CancelInteraction, + CancelInteractionResponse, + ChangeRegistration, + ChangeRegistrationResponse, + CloseApplication, + CloseApplicationResponse, + CreateInteractionChoiceSet, + CreateInteractionChoiceSetResponse, + CreateWindow, + CreateWindowResponse, + DeleteCommand, + DeleteCommandResponse, + DeleteFile, + DeleteFileResponse, + DeleteInteractionChoiceSet, + DeleteInteractionChoiceSetResponse, + DeleteSubMenu, + DeleteSubMenuResponse, + DeleteWindow, + DeleteWindowResponse, + DiagnosticMessage, + DiagnosticMessageResponse, + DialNumber, + DialNumberResponse, + EncodedSyncPData, + EncodedSyncPDataResponse, + EndAudioPassThru, + EndAudioPassThruResponse, + GenericResponseResponse, + GetAppServiceData, + GetAppServiceDataResponse, + GetCloudAppProperties, + GetCloudAppPropertiesResponse, + GetDTCs, + GetDTCsResponse, + GetFile, + GetFileResponse, + GetInteriorVehicleData, + GetInteriorVehicleDataConsent, + GetInteriorVehicleDataConsentResponse, + GetInteriorVehicleDataResponse, + GetSystemCapability, + GetSystemCapabilityResponse, + GetVehicleData, + GetVehicleDataResponse, + GetWayPoints, + GetWayPointsResponse, + ListFiles, + ListFilesResponse, + OnAppInterfaceUnregistered, + OnAppServiceData, + OnAudioPassThru, + OnButtonEvent, + OnButtonPress, + OnCommand, + OnDriverDistraction, + OnEncodedSyncPData, + OnHMIStatus, + OnHashChange, + OnInteriorVehicleData, + OnKeyboardInput, OnLanguageChange, + OnPermissionsChange, + OnRCStatus, + OnSystemCapabilityUpdated, + OnSystemRequest, + OnTBTClientState, + OnTouchEvent, + OnVehicleData, + OnWayPointChange, + PerformAppServiceInteraction, + PerformAppServiceInteractionResponse, + PerformAudioPassThru, + PerformAudioPassThruResponse, + PerformInteraction, + PerformInteractionResponse, + PublishAppService, + PublishAppServiceResponse, PutFile, PutFileResponse, + ReadDID, + ReadDIDResponse, RegisterAppInterface, RegisterAppInterfaceResponse, + ReleaseInteriorVehicleDataModule, + ReleaseInteriorVehicleDataModuleResponse, + ResetGlobalProperties, + ResetGlobalPropertiesResponse, + ScrollableMessage, + ScrollableMessageResponse, + SendHapticData, + SendHapticDataResponse, + SendLocation, + SendLocationResponse, SetAppIcon, SetAppIconResponse, + SetCloudAppProperties, + SetCloudAppPropertiesResponse, + SetDisplayLayout, + SetDisplayLayoutResponse, + SetGlobalProperties, + SetGlobalPropertiesResponse, + SetInteriorVehicleData, + SetInteriorVehicleDataResponse, + SetMediaClockTimer, + SetMediaClockTimerResponse, Show, + ShowAppMenu, + ShowAppMenuResponse, + ShowConstantTBT, + ShowConstantTBTResponse, ShowResponse, + Slider, + SliderResponse, + Speak, + SpeakResponse, + SubscribeButton, + SubscribeButtonResponse, + SubscribeVehicleData, + SubscribeVehicleDataResponse, + SubscribeWayPoints, + SubscribeWayPointsResponse, + SystemRequest, + SystemRequestResponse, + UnpublishAppService, + UnpublishAppServiceResponse, UnregisterAppInterface, - UnregisterAppInterfaceResponse + UnregisterAppInterfaceResponse, + UnsubscribeButton, + UnsubscribeButtonResponse, + UnsubscribeVehicleData, + UnsubscribeVehicleDataResponse, + UnsubscribeWayPoints, + UnsubscribeWayPointsResponse, + UpdateTurnList, + UpdateTurnListResponse }, structs: { + AirbagStatus, AppInfo, + AppServiceCapability, + AppServiceData, + AppServiceManifest, + AppServiceRecord, + AppServicesCapabilities, + AudioControlCapabilities, + AudioControlData, AudioPassThruCapabilities, + BeltStatus, + BodyInformation, ButtonCapabilities, + Choice, + ClimateControlCapabilities, + ClimateControlData, + CloudAppProperties, + ClusterModeStatus, + Coordinate, + DIDResult, + DateTime, DeviceInfo, + DeviceStatus, DisplayCapabilities, + DisplayCapability, + ECallInfo, + EmergencyEvent, + EqualizerSettings, + FuelRange, + GPSData, Grid, HMICapabilities, + HMIPermissions, + HMISettingsControlCapabilities, + HMISettingsControlData, + HapticRect, + HeadLampStatus, Image, ImageField, ImageResolution, + KeyboardProperties, + LightCapabilities, + LightControlCapabilities, + LightControlData, + LightState, + LocationDetails, + MassageCushionFirmness, + MassageModeData, + MediaServiceData, + MediaServiceManifest, MenuParams, MetadataTags, + ModuleData, ModuleInfo, + MyKey, + NavigationCapability, + NavigationInstruction, + NavigationServiceData, + NavigationServiceManifest, + OASISAddress, + ParameterPermissions, + PermissionItem, + PhoneCapability, PresetBankCapabilities, RGBColor, + RadioControlCapabilities, + RadioControlData, + RdsData, + Rectangle, + RemoteControlCapabilities, ScreenParams, SdlMsgVersion, + SeatControlCapabilities, + SeatControlData, + SeatLocation, + SeatLocationCapability, + SeatMemoryAction, + SingleTireStatus, + SisData, SoftButton, SoftButtonCapabilities, + StartTime, + StationIDNumber, + SystemCapability, TTSChunk, + Temperature, TemplateColorScheme, + TemplateConfiguration, TextField, + TireStatus, + TouchCoord, + TouchEvent, TouchEventCapabilities, + Turn, + VehicleDataResult, VehicleType, VideoStreamingCapability, - VideoStreamingFormat + VideoStreamingFormat, + VrHelpItem, + WeatherAlert, + WeatherData, + WeatherServiceData, + WeatherServiceManifest, + WindowCapability, + WindowTypeCapabilities } }, session: { @@ -29167,4 +56771,4 @@ return SDL; }))); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","sources":["../tmp/manager/AppConfig.js","../tmp/manager/lifecycle/LifecycleListener.js","../tmp/util/Enum.js","../tmp/rpc/RpcStruct.js","../tmp/rpc/enums/FunctionID.js","../tmp/rpc/RpcMessage.js","../tmp/rpc/enums/RpcType.js","../tmp/rpc/RpcRequest.js","../tmp/rpc/structs/SdlMsgVersion.js","../tmp/rpc/enums/SpeechCapabilities.js","../tmp/rpc/structs/TTSChunk.js","../tmp/rpc/structs/DeviceInfo.js","../tmp/rpc/structs/AppInfo.js","../tmp/rpc/structs/RGBColor.js","../tmp/rpc/structs/TemplateColorScheme.js","../tmp/rpc/enums/Language.js","../tmp/rpc/enums/AppHMIType.js","../tmp/rpc/messages/RegisterAppInterface.js","../tmp/rpc/enums/Result.js","../tmp/rpc/RpcResponse.js","../tmp/rpc/RpcListener.js","../tmp/protocol/SdlProtocolListener.js","../tmp/protocol/enums/FrameType.js","../../../third_party/bson.common.js","../tmp/util/Bson.js","../tmp/protocol/SdlPacket.js","../../../node_modules/rollup-plugin-node-globals/src/global.js","../../../node_modules/buffer-es6/base64.js","../../../node_modules/buffer-es6/ieee754.js","../../../node_modules/buffer-es6/isArray.js","../../../node_modules/buffer-es6/index.js","../tmp/util/TextEncoder.js","../tmp/util/JsonRpcMarshaller.js","../tmp/protocol/BinaryFrameHeader.js","../tmp/protocol/MessageFrameDisassembler.js","../tmp/transport/TransportListener.js","../tmp/util/Version.js","../tmp/protocol/enums/ServiceType.js","../tmp/protocol/MessageFrameAssembler.js","../tmp/protocol/enums/ControlFrameTags.js","../tmp/util/BitConverter.js","../tmp/protocol/SdlPacketFactory.js","../tmp/rpc/enums/ImageType.js","../tmp/rpc/structs/Image.js","../tmp/rpc/structs/MenuParams.js","../tmp/rpc/messages/AddCommand.js","../tmp/rpc/messages/AddCommandResponse.js","../tmp/rpc/RpcNotification.js","../tmp/rpc/enums/HMILevel.js","../tmp/rpc/enums/AudioStreamingState.js","../tmp/rpc/enums/VideoStreamingState.js","../tmp/rpc/enums/SystemContext.js","../tmp/rpc/messages/OnHmiStatus.js","../tmp/rpc/messages/OnLanguageChange.js","../tmp/rpc/enums/FileType.js","../tmp/rpc/messages/PutFile.js","../tmp/rpc/messages/PutFileResponse.js","../tmp/rpc/enums/TextFieldName.js","../tmp/rpc/enums/CharacterSet.js","../tmp/rpc/structs/TextField.js","../tmp/rpc/structs/ImageResolution.js","../tmp/rpc/enums/ImageFieldName.js","../tmp/rpc/structs/ImageField.js","../tmp/rpc/structs/TouchEventCapabilities.js","../tmp/rpc/structs/ScreenParams.js","../tmp/rpc/enums/DisplayType.js","../tmp/rpc/enums/MediaClockFormat.js","../tmp/rpc/structs/DisplayCapabilities.js","../tmp/rpc/structs/Grid.js","../tmp/rpc/structs/ModuleInfo.js","../tmp/rpc/enums/ButtonName.js","../tmp/rpc/structs/ButtonCapabilities.js","../tmp/rpc/structs/SoftButtonCapabilities.js","../tmp/rpc/structs/PresetBankCapabilities.js","../tmp/rpc/structs/VehicleType.js","../tmp/rpc/enums/HmiZoneCapabilities.js","../tmp/rpc/enums/PrerecordedSpeech.js","../tmp/rpc/enums/SamplingRate.js","../tmp/rpc/enums/BitsPerSample.js","../tmp/rpc/enums/AudioType.js","../tmp/rpc/structs/AudioPassThruCapabilities.js","../tmp/rpc/enums/VrCapabilities.js","../tmp/rpc/structs/HMICapabilities.js","../tmp/rpc/messages/RegisterAppInterfaceResponse.js","../tmp/rpc/messages/SetAppIcon.js","../tmp/rpc/messages/SetAppIconResponse.js","../tmp/rpc/enums/SoftButtonType.js","../tmp/rpc/enums/SystemAction.js","../tmp/rpc/structs/SoftButton.js","../tmp/rpc/enums/MetadataType.js","../tmp/rpc/structs/MetadataTags.js","../tmp/rpc/enums/TextAlignment.js","../tmp/rpc/messages/Show.js","../tmp/rpc/messages/ShowResponse.js","../tmp/rpc/messages/UnregisterAppInterface.js","../tmp/rpc/messages/UnregisterAppInterfaceResponse.js","../tmp/rpc/RpcCreator.js","../tmp/rpc/enums/VideoStreamingProtocol.js","../tmp/rpc/enums/VideoStreamingCodec.js","../tmp/rpc/structs/VideoStreamingFormat.js","../tmp/protocol/SdlProtocolBase.js","../tmp/transport/enums/TransportType.js","../tmp/transport/SdlPsm.js","../tmp/transport/TransportBase.js","../tmp/transport/WebSocketClient.js","../tmp/transport/TransportCallback.js","../tmp/transport/TransportManagerBase.js","../tmp/transport/WebSocketServer.js","../tmp/transport/TransportManager.js","../tmp/protocol/SdlProtocol.js","../tmp/session/ServiceListenerMap.js","../tmp/streaming/video/VideoStreamingParameters.js","../tmp/session/SdlSession.js","../tmp/session/SdlSessionListener.js","../tmp/util/ArrayTools.js","../tmp/manager/lifecycle/LifecycleManager.js","../tmp/rpc/structs/VideoStreamingCapability.js","../tmp/session/SdlServiceListener.js","../tmp/transport/CustomTransport.js","../tmp/transport/TransportConfigBase.js","../tmp/transport/CustomTransportConfig.js","../tmp/transport/SslConfig.js","../tmp/transport/WebSocketClientConfig.js","../tmp/transport/util/TransportRecord.js","../tmp/transport/WebSocketServerConfig.js","../index.js"],"sourcesContent":["/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n// TODO This class may or may not be included in the release. We should determine if\n// there is a better coding pattern for this for javascript.\n\nclass AppConfig {\n    /**\n    * @constructor\n    */\n    constructor () {\n        this._transportConfig = null;\n        this._appId = null;\n        this._appName = null;\n        this._iconName = null;\n        this._iconFile = null;\n        this._shortAppName = null;\n        this._ttsName = null;\n        this._vrSynonyms = null;\n        this._isMediaApp = null;\n        this._languageDesired = null;\n        this._hmiDisplayLanguageDesired = null;\n        this._appTypes = null;\n        this._dayColorScheme = null;\n        this._nightColorScheme = null;\n        this._minimumRPCVersion = null;\n        this._minimumProtocolVersion = null;\n    }\n\n    /**\n    * @param {TransportConfigBase} transportConfig\n    * @return {AppConfig}\n    */\n    setTransportConfig (transportConfig) {\n        this._transportConfig = transportConfig;\n        return this;\n    }\n\n    /**\n    * @return {TransportConfigBase}\n    */\n    getTransportConfig () {\n        return this._transportConfig;\n    }\n\n    /**\n    * @param {String} appId\n    * @return {AppConfig}\n    */\n    setAppId (appId) {\n        this._appId = appId;\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppId () {\n        return this._appId;\n    }\n\n    /**\n    * @param {String} appName\n    * @return {AppConfig}\n    */\n    setAppName (appName) {\n        this._appName = appName;\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppName () {\n        return this._appName;\n    }\n\n    /**\n    * @param {String} iconName\n    * @param {Uint8Array} fileData\n    * @return {AppConfig}\n    */\n    setAppIcon (iconName = 'icon.png', fileData) {\n        // TODO create SdlArtwork\n        this._iconName = iconName;\n        this._iconFile = fileData;\n\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppIconName () {\n        return this._iconName;\n    }\n\n    /**\n    * @return {Uint8Array}\n    */\n    getAppIconFileData () {\n        return this._iconFile;\n    }\n\n    /**\n    * @param {String} shortAppName\n    * @return {AppConfig}\n    */\n    setShortAppName (shortAppName) {\n        this._shortAppName = shortAppName;\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getShortAppName () {\n        return this._shortAppName;\n    }\n\n    /**\n    * @param {Array<TTSChunk>} ttsName\n    * @return {AppConfig}\n    */\n    setTtsName (ttsName) {\n        this._ttsName = ttsName;\n        return this;\n    }\n\n    /**\n    * @return {Array<TTSChunk>}\n    */\n    getTtsName () {\n        return this._ttsName;\n    }\n\n    /**\n    * @param {Array<String>} vrSynonyms\n    * @return {AppConfig}\n    */\n    setVrSynonyms (vrSynonyms) {\n        this._vrSynonyms = vrSynonyms;\n        return this;\n    }\n\n    /**\n    * @return {Array<String>}\n    */\n    getVrSynonyms () {\n        return this._vrSynonyms;\n    }\n\n    /**\n    * @param {Boolean} isMediaApp\n    * @return {AppConfig}\n    */\n    setIsMediaApp (isMediaApp) {\n        this._isMediaApp = isMediaApp;\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    isMediaApp () {\n        return this._isMediaApp;\n    }\n\n    /**\n    * @param {Language} languageDesired\n    * @return {AppConfig}\n    */\n    setLanguageDesired (languageDesired) {\n        this._languageDesired = languageDesired;\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getLanguageDesired () {\n        return this._languageDesired;\n    }\n\n    /**\n    * @param {Language} hmiDisplayLanguageDesired\n    * @return {AppConfig}\n    */\n    setHmiDisplayLanguageDesired (hmiDisplayLanguageDesired) {\n        this._hmiDisplayLanguageDesired = hmiDisplayLanguageDesired;\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getHmiDisplayLanguageDesired () {\n        return this._hmiDisplayLanguageDesired;\n    }\n\n    /**\n    * @param {Array<AppHMIType>} appTypes an array of ordered app types\n    * @return {AppConfig}\n    */\n    setAppTypes (appTypes) {\n        this._appTypes = appTypes;\n        return this;\n    }\n\n    /**\n    * @return {Array<AppHMIType>}\n    */\n    getAppTypes () {\n        return this._appTypes;\n    }\n\n\n    /**\n    * @param {TemplateColorScheme} dayColorScheme\n    * @return {AppConfig}\n    */\n    setDayColorScheme (dayColorScheme) {\n        this._dayColorScheme = dayColorScheme;\n        return this;\n    }\n\n    /**\n    * @return {TemplateColorScheme}\n    */\n    getDayColorScheme () {\n        return this._dayColorScheme;\n    }\n\n    /**\n    * @param {TemplateColorScheme} nightColorScheme\n    * @return {AppConfig}\n    */\n    setNightColorScheme (nightColorScheme) {\n        this._nightColorScheme = nightColorScheme;\n        return this;\n    }\n\n    /**\n    * @return {TemplateColorScheme}\n    */\n    getNightColorScheme () {\n        return this._nightColorScheme;\n    }\n\n    /**\n    * The minimum RPC version that will be permitted to connect.\n    * If the RPC version of the head unit connected is below this version, an UnregisterAppInterface will be sent.\n    *\n    * @param {Version} minimumRPCVersion\n    * @return {AppConfig}\n    */\n    setMinimumRPCVersion (minimumRPCVersion) {\n        this._minimumRPCVersion = minimumRPCVersion;\n        return this;\n    }\n\n    /**\n     *\n    * @return {Version}\n    */\n    getMinimumRPCVersion () {\n        return this._minimumRPCVersion;\n    }\n\n\n    /**\n    * Sets the minimum protocol version that will be permitted to connect.\n    * If the protocol version of the head unit connected is below this version,\n    * the app will disconnect with an EndService protocol message and will not register.\n    * @param {Version} minimumProtocolVersion\n    * @return {AppConfig}\n    */\n    setMinimumProtocolVersion (minimumProtocolVersion) {\n        this._minimumProtocolVersion = minimumProtocolVersion;\n        return this;\n    }\n\n    /**\n    * @return {Version}\n    */\n    getMinimumProtocolVersion () {\n        return this._minimumProtocolVersion;\n    }\n}\n\nexport { AppConfig };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} LifecycleListener\n */\nclass LifecycleListener {\n    /**\n\t * @constructor\n\t */\n    constructor () {\n        this._onProxyConnected = null;\n        this._onProxyClosed = null;\n        this._onServiceStarted = null;\n        this._onServiceEnded = null;\n        this._onError = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProxyConnected (listener) {\n        this._onProxyConnected = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProxyClosed (listener) {\n        this._onProxyClosed = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceStarted (listener) {\n        this._onServiceStarted = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceEnded (listener) {\n        this._onServiceEnded = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnError (listener) {\n        this._onError = listener;\n    }\n\n    /**\n     * @param {LifecycleManager} lifecycleManager\n\n     */\n    onProxyConnected (lifecycleManager) {\n        if (typeof this._onProxyConnected === 'function') {\n            this._onProxyConnected(lifecycleManager);\n        }\n    }\n\n    /**\n     * @param {LifecycleManager} lifecycleManager\n     * @param {String} info\n     * @param {SdlDisconnectedReason} reason\n     */\n    onProxyClosed (lifecycleManager, info, reason) {\n        if (typeof this._onProxyClosed === 'function') {\n            this._onProxyClosed(lifecycleManager, info, reason);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     */\n    onServiceStarted (serviceType, sessionID, correlationID) {\n        if (typeof this._onProtocolSessionEndedNACKed === 'function') {\n            this._onServiceStarted(serviceType, sessionID, correlationID);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     */\n    onServiceEnded (serviceType) {\n        if (typeof this._onServiceEnded === 'function') {\n            this._onServiceEnded(serviceType);\n        }\n    }\n\n    /**\n     * @param {LifecycleManager} lifecycleManager\n     * @param {String} info\n     */\n    onError (lifecycleManager, info) {\n        if (typeof this._onError === 'function') {\n            this._onError(lifecycleManager, info);\n        }\n    }\n}\n\nexport { LifecycleListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        // intentionally empty\n    }\n\n    /**\n    * Returns the key for a given value if the value is found within the key:value map\n    * @param value - A primitive value to find in the map\n    * @param map {Object} - An map of string properties to primitive values\n    * @return {null|String} - Returns null if not found\n    */\n    static _keyForValue (value, map) {\n        for (const key in map) {\n            if (map[key] === value) {\n                return key;\n            }\n        }\n\n        return null;\n    }\n\n    /**\n    * A method for subclasses to implement that does what _keyForValue does\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    keyForValue (value) {\n        throw new Error('method must be overridden');\n    }\n\n    /**\n    * Returns the value for the given key if the key is found within the key:value map\n    * @param value - A primitive value to find in the map\n    * @param map {Object} - An map of string properties to primitive values\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static _valueForKey (key, map) {\n        return map[key] || null;\n    }\n\n    /**\n    * A method for subclasses to implement that does what _valueForKey does\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    valueForKey (key) {\n        throw new Error('method must be overridden');\n    }\n}\n\nexport { Enum };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../util/Enum.js';\n\nclass RpcStruct {\n    /**\n    * @constructor\n    */\n    constructor (parameters = {}) {\n        this._isFormatRequested = false;\n        this._rpcSpecVersion = null;\n        this._parameters = parameters || {};\n    }\n\n    /**\n    * @return {Object}\n    */\n    getParameters () {\n        return this._parameters;\n    }\n\n    /**\n    * @param {String} key\n    * @return {*}\n    */\n    getParameter (key) {\n        return this._parameters[key];\n    }\n\n    /**\n    * @param {String} key\n    * @param {*} value\n    * @return {RpcStruct}\n    */\n    setParameter (key, value) {\n        if (value === null) {\n            delete this._parameters[key];\n        } else {\n            this._parameters[key] = value;\n        }\n\n        return this;\n    }\n\n    /**\n    * @param {Function} tClass\n    * @param {String} key\n    * @return {Object}\n    */\n    getObject (tClass, key) {\n        return this._formatObject(tClass, this.getParameter(key));\n    }\n\n    /**\n    * @param {Function} tClass\n    * @param {Object} obj\n    * @private\n    * @return {null|Object}\n    */\n    _formatObject (tClass, obj) {\n        if (obj === null || obj === undefined) {\n            return null;\n        } else if (obj.constructor === tClass) {\n            // if tClass is String and obj is a String, this should execute\n            return obj;\n        } else if (obj.constructor === String) { // this covers the Enum case too\n            return obj;\n        } else if (obj.constructor === Object) {\n            if (tClass.prototype instanceof RpcStruct) {\n                return new tClass(obj);\n            }\n            return null;\n        } else if (obj.constructor === Array) {\n            if (obj.length > 0) {\n                const outArray = [];\n                for (const item of obj) {\n                    outArray.push(this._formatObject(tClass, item));\n                }\n                return outArray;\n            }\n        }\n        return null;\n    }\n\n    /**\n    * @param {Function} tClass\n    * @param {Object} obj\n    * @param {Boolean} isArray (false)\n    */\n    validateType (tClass, obj, isArray = false) {\n        if (isArray) {\n            if (!Array.isArray(obj)) {\n                throw new Error(`${obj.name} must be an array containing items of type ${tClass.name}`);\n            } else {\n                for (const item of obj) {\n                    this.validateType(tClass, item, false);\n                }\n            }\n        } else if (\n            (tClass.prototype instanceof Enum && tClass.keyForValue(obj) === null)\n            || (tClass.prototype instanceof RpcStruct && obj !== null && obj.constructor !== tClass)\n        ) {\n            throw new Error(`${obj.name} must be of type ${tClass.name}`);\n        }\n    }\n}\n\nexport { RpcStruct };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} FunctionID\n * @property {Object} _MAP\n */\nclass FunctionID extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get RegisterAppInterface () {\n        return FunctionID._MAP.RegisterAppInterface;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get UnregisterAppInterface () {\n        return FunctionID._MAP.UnregisterAppInterface;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SetGlobalProperties () {\n        return FunctionID._MAP.SetGlobalProperties;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ResetGlobalProperties () {\n        return FunctionID._MAP.ResetGlobalProperties;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get AddCommand () {\n        return FunctionID._MAP.AddCommand;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get DeleteCommand () {\n        return FunctionID._MAP.DeleteCommand;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get AddSubMenu () {\n        return FunctionID._MAP.AddSubMenu;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get DeleteSubMenu () {\n        return FunctionID._MAP.DeleteSubMenu;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CreateInteractionChoiceSet () {\n        return FunctionID._MAP.CreateInteractionChoiceSet;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get PerformInteraction () {\n        return FunctionID._MAP.PerformInteraction;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get DeleteInteractionChoiceSet () {\n        return FunctionID._MAP.DeleteInteractionChoiceSet;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get Alert () {\n        return FunctionID._MAP.Alert;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get Show () {\n        return FunctionID._MAP.Show;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get Speak () {\n        return FunctionID._MAP.Speak;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SetMediaClockTimer () {\n        return FunctionID._MAP.SetMediaClockTimer;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get PerformAudioPassThru () {\n        return FunctionID._MAP.PerformAudioPassThru;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get EndAudioPassThru () {\n        return FunctionID._MAP.EndAudioPassThru;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SubscribeButton () {\n        return FunctionID._MAP.SubscribeButton;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get UnsubscribeButton () {\n        return FunctionID._MAP.UnsubscribeButton;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SubscribeVehicleData () {\n        return FunctionID._MAP.SubscribeVehicleData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get UnsubscribeVehicleData () {\n        return FunctionID._MAP.UnsubscribeVehicleData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetVehicleData () {\n        return FunctionID._MAP.GetVehicleData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ReadDID () {\n        return FunctionID._MAP.ReadDID;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetDTCs () {\n        return FunctionID._MAP.GetDTCs;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ScrollableMessage () {\n        return FunctionID._MAP.ScrollableMessage;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get Slider () {\n        return FunctionID._MAP.Slider;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ShowConstantTBT () {\n        return FunctionID._MAP.ShowConstantTBT;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get AlertManeuver () {\n        return FunctionID._MAP.AlertManeuver;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get UpdateTurnList () {\n        return FunctionID._MAP.UpdateTurnList;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ChangeRegistration () {\n        return FunctionID._MAP.ChangeRegistration;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GenericResponse () {\n        return FunctionID._MAP.GenericResponse;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get PutFile () {\n        return FunctionID._MAP.PutFile;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get DeleteFile () {\n        return FunctionID._MAP.DeleteFile;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ListFiles () {\n        return FunctionID._MAP.ListFiles;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SetAppIcon () {\n        return FunctionID._MAP.SetAppIcon;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SetDisplayLayout () {\n        return FunctionID._MAP.SetDisplayLayout;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get DiagnosticMessage () {\n        return FunctionID._MAP.DiagnosticMessage;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SystemRequest () {\n        return FunctionID._MAP.SystemRequest;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SendLocation () {\n        return FunctionID._MAP.SendLocation;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get DialNumber () {\n        return FunctionID._MAP.DialNumber;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ButtonPress () {\n        return FunctionID._MAP.ButtonPress;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetInteriorVehicleData () {\n        return FunctionID._MAP.GetInteriorVehicleData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SetInteriorVehicleData () {\n        return FunctionID._MAP.SetInteriorVehicleData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetWayPoints () {\n        return FunctionID._MAP.GetWayPoints;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SubscribeWayPoints () {\n        return FunctionID._MAP.SubscribeWayPoints;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get UnsubscribeWayPoints () {\n        return FunctionID._MAP.UnsubscribeWayPoints;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetSystemCapability () {\n        return FunctionID._MAP.GetSystemCapability;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SendHapticData () {\n        return FunctionID._MAP.SendHapticData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SetCloudAppProperties () {\n        return FunctionID._MAP.SetCloudAppProperties;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetCloudAppProperties () {\n        return FunctionID._MAP.GetCloudAppProperties;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get PublishAppService () {\n        return FunctionID._MAP.PublishAppService;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetAppServiceData () {\n        return FunctionID._MAP.GetAppServiceData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetFile () {\n        return FunctionID._MAP.GetFile;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get PerformAppServiceInteraction () {\n        return FunctionID._MAP.PerformAppServiceInteraction;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get UnpublishAppService () {\n        return FunctionID._MAP.UnpublishAppService;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CancelInteraction () {\n        return FunctionID._MAP.CancelInteraction;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CloseApplication () {\n        return FunctionID._MAP.CloseApplication;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ShowAppMenu () {\n        return FunctionID._MAP.ShowAppMenu;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CreateWindow () {\n        return FunctionID._MAP.CreateWindow;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get DeleteWindow () {\n        return FunctionID._MAP.DeleteWindow;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get GetInteriorVehicleDataConsent () {\n        return FunctionID._MAP.GetInteriorVehicleDataConsent;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get ReleaseInteriorVehicleDataModule () {\n        return FunctionID._MAP.ReleaseInteriorVehicleDataModule;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnHMIStatus () {\n        return FunctionID._MAP.OnHMIStatus;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnAppInterfaceUnregistered () {\n        return FunctionID._MAP.OnAppInterfaceUnregistered;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnButtonEvent () {\n        return FunctionID._MAP.OnButtonEvent;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnButtonPress () {\n        return FunctionID._MAP.OnButtonPress;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnVehicleData () {\n        return FunctionID._MAP.OnVehicleData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnCommand () {\n        return FunctionID._MAP.OnCommand;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnTBTClientState () {\n        return FunctionID._MAP.OnTBTClientState;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnDriverDistraction () {\n        return FunctionID._MAP.OnDriverDistraction;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnPermissionsChange () {\n        return FunctionID._MAP.OnPermissionsChange;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnAudioPassThru () {\n        return FunctionID._MAP.OnAudioPassThru;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnLanguageChange () {\n        return FunctionID._MAP.OnLanguageChange;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnKeyboardInput () {\n        return FunctionID._MAP.OnKeyboardInput;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnTouchEvent () {\n        return FunctionID._MAP.OnTouchEvent;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnSystemRequest () {\n        return FunctionID._MAP.OnSystemRequest;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnHashChange () {\n        return FunctionID._MAP.OnHashChange;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnInteriorVehicleData () {\n        return FunctionID._MAP.OnInteriorVehicleData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnWayPointChange () {\n        return FunctionID._MAP.OnWayPointChange;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnRCStatus () {\n        return FunctionID._MAP.OnRCStatus;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnAppServiceData () {\n        return FunctionID._MAP.OnAppServiceData;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get OnSystemCapabilityUpdated () {\n        return FunctionID._MAP.OnSystemCapabilityUpdated;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return FunctionID._valueForKey(key, FunctionID._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return FunctionID._keyForValue(value, FunctionID._MAP);\n    }\n}\n\nFunctionID._MAP = Object.freeze({\n    'RegisterAppInterface':                0x01,\n    'UnregisterAppInterface':              0x02,\n    'SetGlobalProperties':                 0x03,\n    'ResetGlobalProperties':               0x04,\n    'AddCommand':                          0x05,\n    'DeleteCommand':                       0x06,\n    'AddSubMenu':                          0x07,\n    'DeleteSubMenu':                       0x08,\n    'CreateInteractionChoiceSet':          0x09,\n    'PerformInteraction':                  0x0A,\n    'DeleteInteractionChoiceSet':          0x0B,\n    'Alert':                               0x0C,\n    'Show':                                0x0D,\n    'Speak':                               0x0E,\n    'SetMediaClockTimer':                  0x0F,\n    'PerformAudioPassThru':                0x10,\n    'EndAudioPassThru':                    0x11,\n    'SubscribeButton':                     0x12,\n    'UnsubscribeButton':                   0x13,\n    'SubscribeVehicleData':                0x14,\n    'UnsubscribeVehicleData':              0x15,\n    'GetVehicleData':                      0x16,\n    'ReadDID':                             0x17,\n    'GetDTCs':                             0x18,\n    'ScrollableMessage':                   0x19,\n    'Slider':                              0x1A,\n    'ShowConstantTBT':                     0x1B,\n    'AlertManeuver':                       0x1C,\n    'UpdateTurnList':                      0x1D,\n    'ChangeRegistration':                  0x1E,\n    'GenericResponse':                     0x1F,\n    'PutFile':                             0x20,\n    'DeleteFile':                          0x21,\n    'ListFiles':                           0x22,\n    'SetAppIcon':                          0x23,\n    'SetDisplayLayout':                    0x24,\n    'DiagnosticMessage':                   0x25,\n    'SystemRequest':                       0x26,\n    'SendLocation':                        0x27,\n    'DialNumber':                          0x28,\n    'ButtonPress':                         0x29,\n    'GetInteriorVehicleData':              0x2B,\n    'SetInteriorVehicleData':              0x2C,\n    'GetWayPoints':                        0x2D,\n    'SubscribeWayPoints':                  0x2E,\n    'UnsubscribeWayPoints':                0x2F,\n    'GetSystemCapability':                 0x30,\n    'SendHapticData':                      0x31,\n    'SetCloudAppProperties':               0x32,\n    'GetCloudAppProperties':               0x33,\n    'PublishAppService':                   0x34,\n    'GetAppServiceData':                   0x35,\n    'GetFile':                             0x36,\n    'PerformAppServiceInteraction':        0x37,\n    'UnpublishAppService':                 0x38,\n    'CancelInteraction':                   0x39,\n    'CloseApplication':                    0x3A,\n    'ShowAppMenu':                         0x3B,\n    'CreateWindow':                        0x3C,\n    'DeleteWindow':                        0x3D,\n    'GetInteriorVehicleDataConsent':       0x3E,\n    'ReleaseInteriorVehicleDataModule':    0x3F,\n    'OnHMIStatus':                         0x8000,\n    'OnAppInterfaceUnregistered':          0x8001,\n    'OnButtonEvent':                       0x8002,\n    'OnButtonPress':                       0x8003,\n    'OnVehicleData':                       0x8004,\n    'OnCommand':                           0x8005,\n    'OnTBTClientState':                    0x8006,\n    'OnDriverDistraction':                 0x8007,\n    'OnPermissionsChange':                 0x8008,\n    'OnAudioPassThru':                     0x8009,\n    'OnLanguageChange':                    0x800A,\n    'OnKeyboardInput':                     0x800B,\n    'OnTouchEvent':                        0x800C,\n    'OnSystemRequest':                     0x800D,\n    'OnHashChange':                        0x800E,\n    'OnInteriorVehicleData':               0x800F,\n    'OnWayPointChange':                    0x8010,\n    'OnRCStatus':                          0x8011,\n    'OnAppServiceData':                    0x8012,\n    'OnSystemCapabilityUpdated':           0x8013,\n});\n\nexport { FunctionID };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from './RpcStruct.js';\nimport { FunctionID } from './enums/FunctionID.js';\n\n/**\n * @typedef {Object} RpcMessage\n * @property {RpcType} rpcType\n */\nclass RpcMessage extends RpcStruct {\n    /*\n    {\n        \"rpcType\": \"Request\",\n        \"functionName\": \"RegisterAppInterface\",\n        \"coorelationID\": \"320948\",\n        \"isEncrypted\": false,\n        \"parameters\": {\n            \"appName\": \"Hello\"\n        },\n        \"bulkData\": \"...\",\n    }\n    */\n\n    /**\n    * @constructor\n    */\n    constructor (store = {}) {\n        super(store.parameters);\n        this._isEncrypted = false;\n        this._rpcType = store.rpcType;\n        this._functionName = store.functionName;\n        this._correlationID = store.correlationID;\n        this.setBulkData(store.bulkData);\n    }\n\n    /**\n    * @return {RpcType}\n    */\n    getRPCType () {\n        return this._rpcType;\n    }\n\n    /**\n    * @param {RpcType} type\n    * @return {RpcMessage}\n    */\n    setRPCType (type) {\n        this._rpcType = type;\n\n        return this;\n    }\n\n    /**\n    * @return {FunctionID} type\n    */\n    getFunctionName () {\n        return this._functionName;\n    }\n\n    /**\n    * @param {FunctionID} name\n    * @return {RpcMessage}\n    */\n    setFunctionName (name) {\n        if (typeof name !== 'string') {\n            this._functionName = FunctionID.keyForValue(name);\n        } else {\n            this._functionName = name;\n        }\n\n        return this;\n    }\n\n    /**\n    * @return {String} type\n    */\n    getCorrelationId () {\n        return this._correlationID;\n    }\n\n    /**\n    * @param {String} name\n    * @return {RpcMessage}\n    */\n    setCorrelationId (id) {\n        this._correlationID = id;\n\n        return this;\n    }\n\n    /**\n    * @return {Uint8Array} data\n    */\n    getBulkData () {\n        return this._bulkData;\n    }\n\n    /**\n    * @param {UInt8Array} data\n    * @return {RpcMessage}\n    */\n    setBulkData (data = null) {\n        if (data !== null) {\n            this._bulkData = data.slice(0);\n        } else {\n            this._bulkData = null;\n        }\n\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getIsEncrypted () {\n        return this._isEncrypted;\n    }\n\n    /**\n    * @param {Boolean} bool\n    * @return {RpcMessage}\n    */\n    setIsEncrypted (bool) {\n        this._isEncrypted = bool;\n\n        return this;\n    }\n}\n\nexport { RpcMessage };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} RpcType\n * @property {Object} _MAP\n */\nclass RpcType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get NOTIFICATION () {\n        return RpcType._MAP.NOTIFICATION;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get RESPONSE () {\n        return RpcType._MAP.RESPONSE;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REQUEST () {\n        return RpcType._MAP.REQUEST;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return RpcType._valueForKey(key, RpcType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return RpcType._keyForValue(value, RpcType._MAP);\n    }\n}\n\nRpcType._MAP = Object.freeze({\n    'NOTIFICATION': 0x2,\n    'RESPONSE': 0x1,\n    'REQUEST': 0x0,\n});\n\nexport { RpcType };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n\nimport { RpcMessage } from './RpcMessage.js';\nimport { RpcType } from './enums/RpcType.js';\n\nclass RpcRequest extends RpcMessage {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setRPCType(RpcType.REQUEST);\n        this._promise = null;\n    }\n\n    /**\n    * @return {Promise}\n    */\n    getOnRPCResponsePromise () {\n        return this._promise;\n    }\n\n    /**\n    * @param {Promise} promise\n    * @return {RpcMessage}\n    */\n    setOnRPCResponsePromise (promise) {\n        this.validateType(Promise, promise);\n\n        this._promise = promise;\n        return this;\n    }\n}\n\nexport { RpcRequest };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass SdlMsgVersion extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Number} the major version of this object\n    * @return {SdlMsgVersion}\n    */\n    setMajorVersion (value) {\n        this.setParameter(SdlMsgVersion.KEY_MAJOR_VERSION, value);\n        return this;\n    }\n\n    /**\n    * @return {Number} the major version of this object\n    */\n    getMajorVersion () {\n        return this.getParameter(SdlMsgVersion.KEY_MAJOR_VERSION);\n    }\n\n    /**\n    * @param {Number} the minor version of this object\n    * @return {SdlMsgVersion}\n    */\n    setMinorVersion (value) {\n        this.setParameter(SdlMsgVersion.KEY_MINOR_VERSION, value);\n        return this;\n    }\n\n    /**\n    * @return {Number} the minor version of this object\n    */\n    getMinorVersion () {\n        return this.getParameter(SdlMsgVersion.KEY_MINOR_VERSION);\n    }\n\n    /**\n    * @param {Number} the patch version of this object\n    * @return {SdlMsgVersion}\n    */\n    setPatchVersion (value) {\n        this.setParameter(SdlMsgVersion.KEY_PATCH_VERSION, value);\n        return this;\n    }\n\n    /**\n    * @return {Number} the patch version of this objects\n    */\n    getPatchVersion () {\n        return this.getParameter(SdlMsgVersion.KEY_PATCH_VERSION);\n    }\n}\n\nSdlMsgVersion.KEY_MAJOR_VERSION = 'majorVersion';\nSdlMsgVersion.KEY_MINOR_VERSION = 'minorVersion';\nSdlMsgVersion.KEY_PATCH_VERSION = 'patchVersion';\n\nexport { SdlMsgVersion };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} SpeechCapabilities\n * @property {Object} _MAP\n */\nclass SpeechCapabilities extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SC_TEXT () {\n        return SpeechCapabilities._MAP.SC_TEXT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SAPI_PHONEMES () {\n        return SpeechCapabilities._MAP.SAPI_PHONEMES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LHPLUS_PHONEMES () {\n        return SpeechCapabilities._MAP.LHPLUS_PHONEMES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRE_RECORDED () {\n        return SpeechCapabilities._MAP.PRE_RECORDED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SILENCE () {\n        return SpeechCapabilities._MAP.SILENCE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FILE () {\n        return SpeechCapabilities._MAP.FILE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return SpeechCapabilities._valueForKey(key, SpeechCapabilities._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return SpeechCapabilities._keyForValue(value, SpeechCapabilities._MAP);\n    }\n}\n\nSpeechCapabilities._MAP = Object.freeze({\n    'SC_TEXT': 'TEXT',\n    'SAPI_PHONEMES': 'SAPI_PHONEMES',\n    'LHPLUS_PHONEMES': 'LHPLUS_PHONEMES',\n    'PRE_RECORDED': 'PRE_RECORDED',\n    'SILENCE': 'SILENCE',\n    'FILE': 'FILE',\n});\n\nexport { SpeechCapabilities };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SpeechCapabilities } from '../enums/SpeechCapabilities.js';\n\nclass TTSChunk extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {String} text\n    * @return {TTSChunk}\n    */\n    setText (text) {\n        this.setParameter(TTSChunk.KEY_TEXT, text);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getText () {\n        return this.getParameter(TTSChunk.KEY_TEXT);\n    }\n\n    /**\n    * @param {SpeechCapabilities} type\n    * @return {TTSChunk}\n    */\n    setType (type) {\n        this.validateType(SpeechCapabilities, type);\n\n        this.setParameter(TTSChunk.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n    * @return {SpeechCapabilities}\n    */\n    getType () {\n        return this.getObject(SpeechCapabilities, TTSChunk.KEY_TYPE);\n    }\n}\n\nTTSChunk.KEY_TEXT = 'text';\nTTSChunk.KEY_TYPE = 'type';\n\nexport { TTSChunk };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass DeviceInfo extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {String} hardware\n    * @return {DeviceInfo}\n    */\n    setHardware (hardware) {\n        this.validateType(String, hardware);\n\n        this.setParameter(DeviceInfo.KEY_HARDWARE, hardware);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getHardware () {\n        return this.getParameter(DeviceInfo.KEY_HARDWARE);\n    }\n\n\n    /**\n    * @param {String} firmwareRev\n    * @return {DeviceInfo}\n    */\n    setFirmwareRev (firmwareRev) {\n        this.validateType(String, firmwareRev);\n\n        this.setParameter(DeviceInfo.KEY_FIRMWARE_REV, firmwareRev);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getFirmwareRev () {\n        return this.getParameter(DeviceInfo.KEY_FIRMWARE_REV);\n    }\n\n\n    /**\n    * @param {String} os\n    * @return {DeviceInfo}\n    */\n    setOs (os) {\n        this.validateType(String, os);\n\n        this.setParameter(DeviceInfo.KEY_OS, os);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getOs () {\n        return this.getParameter(DeviceInfo.KEY_OS);\n    }\n\n    /**\n    * @param {String} osVersion\n    * @return {DeviceInfo}\n    */\n    setOsVersion (osVersion) {\n        this.validateType(String, osVersion);\n\n        this.setParameter(DeviceInfo.KEY_OS_VERSION, osVersion);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getOsVersion () {\n        return this.getParameter(DeviceInfo.KEY_OS_VERSION);\n    }\n\n\n    /**\n    * @param {String} carrier\n    * @return {DeviceInfo}\n    */\n    setCarrier (carrier) {\n        this.validateType(String, carrier);\n\n        this.setParameter(DeviceInfo.KEY_CARRIER, carrier);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getCarrier () {\n        return this.getParameter(DeviceInfo.KEY_CARRIER);\n    }\n\n\n    /**\n    * @param {Number} maxNumberRFCOMMPorts\n    * @return {DeviceInfo}\n    */\n    setMaxNumberRFCOMMPorts (maxNumberRFCOMMPorts) {\n        this.validateType(Number, maxNumberRFCOMMPorts);\n\n        this.setParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS, maxNumberRFCOMMPorts);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getMaxNumberRFCOMMPorts () {\n        return this.getParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS);\n    }\n}\n\nDeviceInfo.KEY_HARDWARE = 'hardware';\nDeviceInfo.KEY_FIRMWARE_REV = 'firmwareRev';\nDeviceInfo.KEY_OS = 'os';\nDeviceInfo.KEY_OS_VERSION = 'osVersion';\nDeviceInfo.KEY_CARRIER = 'carrier';\nDeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS = 'maxNumberRFCOMMPorts';\n\nexport { DeviceInfo };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass AppInfo extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {String} appDisplayName\n    * @return {AppInfo}\n    */\n    setAppDisplayName (appDisplayName) {\n        this.setParameter(AppInfo.KEY_APP_DISPLAY_NAME, appDisplayName);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppDisplayName () {\n        return this.getParameter(AppInfo.KEY_APP_DISPLAY_NAME);\n    }\n\n\n    /**\n    * @param {String} appBundleID\n    * @return {AppInfo}\n    */\n    setAppBundleID (appBundleID) {\n        this.setParameter(AppInfo.KEY_APP_BUNDLE_ID, appBundleID);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppBundleID () {\n        return this.getParameter(AppInfo.KEY_APP_BUNDLE_ID);\n    }\n\n\n    /**\n    * @param {String} appVersion\n    * @return {AppInfo}\n    */\n    setAppVersion (appVersion) {\n        this.setParameter(AppInfo.KEY_APP_VERSION, appVersion);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppVersion () {\n        return this.getParameter(AppInfo.KEY_APP_VERSION);\n    }\n\n    /**\n    * @param {String} appIcon string of the app icon file name\n    * @return {AppInfo}\n    */\n    setAppIcon (appIcon) {\n        this.setParameter(AppInfo.KEY_APP_ICON, appIcon);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppIcon () {\n        return this.getParameter(AppInfo.KEY_APP_ICON);\n    }\n}\n\nAppInfo.KEY_APP_DISPLAY_NAME = 'appDisplayName';\nAppInfo.KEY_APP_BUNDLE_ID = 'appBundleID';\nAppInfo.KEY_APP_VERSION = 'appVersion';\nAppInfo.KEY_APP_ICON = 'appIcon';\n\nexport { AppInfo };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass RGBColor extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Number} redValue\n    * @return {RGBColor}\n    */\n    setRedValue (redValue) {\n        this.setParameter(RGBColor.KEY_RED, redValue);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getRedValue () {\n        return this.getParameter(RGBColor.KEY_RED);\n    }\n\n\n    /**\n    * @param {Number} greenValue\n    * @return {RGBColor}\n    */\n    setGreenValue (greenValue) {\n        this.setParameter(RGBColor.KEY_GREEN, greenValue);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getGreenValue () {\n        return this.getParameter(RGBColor.KEY_GREEN);\n    }\n\n\n    /**\n    * @param {Number} blueValue\n    * @return {RGBColor}\n    */\n    setBlueValue (blueValue) {\n        this.setParameter(RGBColor.KEY_BLUE, blueValue);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getBlueValue () {\n        return this.getParameter(RGBColor.KEY_BLUE);\n    }\n}\n\nRGBColor.KEY_RED = 'red';\nRGBColor.KEY_GREEN = 'green';\nRGBColor.KEY_BLUE = 'blue';\n\nexport { RGBColor };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { RGBColor } from './RGBColor.js';\n\nclass TemplateColorScheme extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {RGBColor} primaryColor\n    * @return {TemplateColorScheme}\n    */\n    setPrimaryColor (primaryColor) {\n        this.validateType(RGBColor, primaryColor);\n\n        this.setParameter(TemplateColorScheme.KEY_PRIMARY_COLOR, primaryColor);\n        return this;\n    }\n\n    /**\n    * @return {RGBColor}\n    */\n    getPrimaryColor () {\n        return this.getObject(RGBColor, TemplateColorScheme.KEY_PRIMARY_COLOR);\n    }\n\n    /**\n    * @param {RGBColor} secondaryColor\n    * @return {TemplateColorScheme}\n    */\n    setSecondaryColor (secondaryColor) {\n        this.validateType(RGBColor, secondaryColor);\n\n        this.setParameter(TemplateColorScheme.KEY_SECONDARY_COLOR, secondaryColor);\n        return this;\n    }\n\n    /**\n    * @return {RGBColor}\n    */\n    getSecondaryColor () {\n        return this.getObject(RGBColor, TemplateColorScheme.KEY_SECONDARY_COLOR);\n    }\n\n    /**\n    * @param {RGBColor} backgroundColor\n    * @return {TemplateColorScheme}\n    */\n    setBackgroundColor (backgroundColor) {\n        this.validateType(RGBColor, backgroundColor);\n\n        this.setParameter(TemplateColorScheme.KEY_BACKGROUND_COLOR, backgroundColor);\n        return this;\n    }\n\n    /**\n    * @return {RGBColor}\n    */\n    getBackgroundColor () {\n        return this.getObject(RGBColor, TemplateColorScheme.KEY_BACKGROUND_COLOR);\n    }\n}\n\nTemplateColorScheme.KEY_PRIMARY_COLOR = 'primaryColor';\nTemplateColorScheme.KEY_SECONDARY_COLOR = 'secondaryColor';\nTemplateColorScheme.KEY_BACKGROUND_COLOR = 'backgroundColor';\n\nexport { TemplateColorScheme };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} Language\n * @property {Object} _MAP\n */\nclass Language extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EN_SA () {\n        return Language._MAP.EN_SA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HE_IL () {\n        return Language._MAP.HE_IL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RO_RO () {\n        return Language._MAP.RO_RO;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UK_UA () {\n        return Language._MAP.UK_UA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ID_ID () {\n        return Language._MAP.ID_ID;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VI_VN () {\n        return Language._MAP.VI_VN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MS_MY () {\n        return Language._MAP.MS_MY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HI_IN () {\n        return Language._MAP.HI_IN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NL_BE () {\n        return Language._MAP.NL_BE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EL_GR () {\n        return Language._MAP.EL_GR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HU_HU () {\n        return Language._MAP.HU_HU;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FI_FI () {\n        return Language._MAP.FI_FI;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SK_SK () {\n        return Language._MAP.SK_SK;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EN_US () {\n        return Language._MAP.EN_US;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ES_MX () {\n        return Language._MAP.ES_MX;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FR_CA () {\n        return Language._MAP.FR_CA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DE_DE () {\n        return Language._MAP.DE_DE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ES_ES () {\n        return Language._MAP.ES_ES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EN_GB () {\n        return Language._MAP.EN_GB;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RU_RU () {\n        return Language._MAP.RU_RU;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TR_TR () {\n        return Language._MAP.TR_TR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PL_PL () {\n        return Language._MAP.PL_PL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FR_FR () {\n        return Language._MAP.FR_FR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IT_IT () {\n        return Language._MAP.IT_IT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SV_SE () {\n        return Language._MAP.SV_SE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PT_PT () {\n        return Language._MAP.PT_PT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NL_NL () {\n        return Language._MAP.NL_NL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EN_AU () {\n        return Language._MAP.EN_AU;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ZH_CN () {\n        return Language._MAP.ZH_CN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ZH_TW () {\n        return Language._MAP.ZH_TW;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get JA_JP () {\n        return Language._MAP.JA_JP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AR_SA () {\n        return Language._MAP.AR_SA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get KO_KR () {\n        return Language._MAP.KO_KR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PT_BR () {\n        return Language._MAP.PT_BR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CS_CZ () {\n        return Language._MAP.CS_CZ;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DA_DK () {\n        return Language._MAP.DA_DK;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NO_NO () {\n        return Language._MAP.NO_NO;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EN_IN () {\n        return Language._MAP.EN_IN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TH_TH () {\n        return Language._MAP.TH_TH;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return Language._valueForKey(key, Language._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return Language._keyForValue(value, Language._MAP);\n    }\n}\n\nLanguage._MAP = Object.freeze({\n    'EN_SA': 'EN-SA',\n    'HE_IL': 'HE-IL',\n    'RO_RO': 'RO-RO',\n    'UK_UA': 'UK-UA',\n    'ID_ID': 'ID-ID',\n    'VI_VN': 'VI-VN',\n    'MS_MY': 'MS-MY',\n    'HI_IN': 'HI-IN',\n    'NL_BE': 'NL-BE',\n    'EL_GR': 'EL-GR',\n    'HU_HU': 'HU-HU',\n    'FI_FI': 'FI-FI',\n    'SK_SK': 'SK-SK',\n    'EN_US': 'EN-US',\n    'ES_MX': 'ES-MX',\n    'FR_CA': 'FR-CA',\n    'DE_DE': 'DE-DE',\n    'ES_ES': 'ES-ES',\n    'EN_GB': 'EN-GB',\n    'RU_RU': 'RU-RU',\n    'TR_TR': 'TR-TR',\n    'PL_PL': 'PL-PL',\n    'FR_FR': 'FR-FR',\n    'IT_IT': 'IT-IT',\n    'SV_SE': 'SV-SE',\n    'PT_PT': 'PT-PT',\n    'NL_NL': 'NL-NL',\n    'EN_AU': 'EN-AU',\n    'ZH_CN': 'ZH-CN',\n    'ZH_TW': 'ZH-TW',\n    'JA_JP': 'JA-JP',\n    'AR_SA': 'AR-SA',\n    'KO_KR': 'KO-KR',\n    'PT_BR': 'PT-BR',\n    'CS_CZ': 'CS-CZ',\n    'DA_DK': 'DA-DK',\n    'NO_NO': 'NO-NO',\n    'EN_IN': 'EN-IN',\n    'TH_TH': 'TH-TH',\n});\n\n\nexport { Language };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} AppHMIType\n * @property {Object} _MAP\n */\nclass AppHMIType extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFAULT () {\n        return AppHMIType._MAP.DEFAULT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get COMMUNICATION () {\n        return AppHMIType._MAP.COMMUNICATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MEDIA () {\n        return AppHMIType._MAP.MEDIA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MESSAGING () {\n        return AppHMIType._MAP.MESSAGING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAVIGATION () {\n        return AppHMIType._MAP.NAVIGATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INFORMATION () {\n        return AppHMIType._MAP.INFORMATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SOCIAL () {\n        return AppHMIType._MAP.SOCIAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BACKGROUND_PROCESS () {\n        return AppHMIType._MAP.BACKGROUND_PROCESS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TESTING () {\n        return AppHMIType._MAP.TESTING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SYSTEM () {\n        return AppHMIType._MAP.SYSTEM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PROJECTION () {\n        return AppHMIType._MAP.PROJECTION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REMOTE_CONTROL () {\n        return AppHMIType._MAP.REMOTE_CONTROL;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return AppHMIType._valueForKey(key, AppHMIType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return AppHMIType._keyForValue(value, AppHMIType._MAP);\n    }\n}\n\nAppHMIType._MAP = Object.freeze({\n    'DEFAULT': 'DEFAULT',\n    'COMMUNICATION': 'COMMUNICATION',\n    'MEDIA': 'MEDIA',\n    'MESSAGING': 'MESSAGING',\n    'NAVIGATION': 'NAVIGATION',\n    'INFORMATION': 'INFORMATION',\n    'SOCIAL': 'SOCIAL',\n    'BACKGROUND_PROCESS': 'BACKGROUND_PROCESS',\n    'TESTING': 'TESTING',\n    'SYSTEM': 'SYSTEM',\n    'PROJECTION': 'PROJECTION',\n    'REMOTE_CONTROL': 'REMOTE_CONTROL',\n});\n\nexport { AppHMIType };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { SdlMsgVersion } from '../structs/SdlMsgVersion.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { DeviceInfo } from '../structs/DeviceInfo.js';\nimport { AppInfo } from '../structs/AppInfo.js';\nimport { TemplateColorScheme } from '../structs/TemplateColorScheme.js';\n\nimport { Language } from '../enums/Language.js';\nimport { AppHMIType } from '../enums/AppHMIType.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass RegisterAppInterface extends RpcRequest {\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.RegisterAppInterface);\n    }\n\n    /**\n    * @param {SdlMsgVersion} The max RPC Spec version supported by this library\n    * @return {RegisterAppInterface}\n    */\n    setSdlMsgVersion (sdlMsgVersion) {\n        this.validateType(SdlMsgVersion, sdlMsgVersion);\n\n        this.setParameter(RegisterAppInterface.KEY_SDL_MSG_VERSION, sdlMsgVersion);\n        return this;\n    }\n\n    /**\n    * @return {SdlMsgVersion}\n    */\n    getSdlMsgVersion () {\n        return this.getObject(SdlMsgVersion, RegisterAppInterface.KEY_SDL_MSG_VERSION);\n    }\n\n\n    /**\n    * @param {String} appName the name of the app that is registering\n    * @return {RegisterAppInterface}\n    */\n    setAppName (appName) {\n        this.validateType(String, appName);\n\n        this.setParameter(RegisterAppInterface.KEY_APP_NAME, appName);\n        return this;\n    }\n\n    /**\n    * @return {String} the app name\n    */\n    getAppName () {\n        return this.getParameter(RegisterAppInterface.KEY_APP_NAME);\n    }\n\n    /**\n   * @param {Array<TTSChunk>} ttsNames TTS string for VR recognition of the mobile application name, e.g. \"My S D L App\".\n   *                                   Meant to overcome any failing on speech engine in properly pronouncing / understanding\n   *                                   app name. Needs to be unique over all applications from the same device. May not be\n   *                                   empty. May not start with a new line character. Only characters from char set\n   * @return {RegisterAppInterface}\n   */\n    setTtsName (ttsNames) {\n        this.setParameter(RegisterAppInterface.KEY_TTS_NAME, ttsNames);\n        return this;\n    }\n\n    /**\n    * @return {Array<TTSChunk>}\n    */\n    getTtsName () {\n        return this.getObject(TTSChunk, RegisterAppInterface.KEY_TTS_NAME);\n    }\n\n    /**\n    * @param {String}  ngnppName Provides an abbreviated version of the app name (if needed), that will be displayed\n    *                            on the NGN media screen. If not provided, the appName is used instead (and\n    *                            will be truncated if too long)Only characters from char set.\n    * @return {RegisterAppInterface}\n    */\n    setNgnMediaScreenAppName (ngnppName) {\n        this.validateType(String, ngnppName);\n\n        this.setParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME, ngnppName);\n        return this;\n    }\n\n    /**\n    * @return {String} an abbreviated version of the app name\n    */\n    getNgnMediaScreenAppName () {\n        return this.getParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME);\n    }\n\n    /**\n    * @param {Array<String>} vrSynonyms Defines an additional voice recognition command. May not\n    *                                   interfere with any app name of previously registered applications\n    *                                   from the same device and any predefined blacklist of words (global\n    *                                   commands)Only characters from char set\n    * @return {RegisterAppInterface}\n    */\n    setVrSynonyms (vrSynonyms) {\n        this.setParameter(RegisterAppInterface.KEY_VR_SYNONYMS, vrSynonyms);\n        return this;\n    }\n\n    /**\n    * @return {Array<String>}\n    */\n    getVrSynonyms () {\n        return this.getParameter(RegisterAppInterface.KEY_VR_SYNONYMS);\n    }\n\n    /**\n    * @param {Boolean} isMediaApplication Indicates if the application is a media or a non-media application.\n    *                                     Only media applications will be able to stream audio to the module\n    *                                     that is audible outside of the BT media source.\n    * @return {RegisterAppInterface}\n    */\n    setIsMediaApplication (isMediaApplication) {\n        this.setParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION, isMediaApplication);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getIsMediaApplication () {\n        return this.getParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION);\n    }\n\n    /**\n    * @param {Language} languageDesired\n    * @return {RegisterAppInterface}\n    */\n    setLanguageDesired (languageDesired) {\n        this.validateType(Language, languageDesired);\n\n        this.setParameter(RegisterAppInterface.KEY_LANGUAGE_DESIRED, languageDesired);\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getLanguageDesired () {\n        return this.getObject(Language, RegisterAppInterface.KEY_LANGUAGE_DESIRED);\n    }\n\n\n    /**\n    * @param {Language} hmiDisplayLanguageDesired\n    * @return {RegisterAppInterface}\n    */\n    setHmiDisplayLanguageDesired (hmiDisplayLanguageDesired) {\n        this.validateType(Language, hmiDisplayLanguageDesired);\n\n        this.setParameter(RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED, hmiDisplayLanguageDesired);\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getHmiDisplayLanguageDesired () {\n        return this.getObject(Language, RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED);\n    }\n\n\n    /**\n    * @param {Array<AppHMIType>} appHMIType\n    * @return {RegisterAppInterface}\n    */\n    setAppHmiType (appHMIType) {\n        // TODO make validate type accept arrays\n        // this.validateType(AppHMIType, appHMIType);\n\n        this.setParameter(RegisterAppInterface.KEY_APP_HMI_TYPE, appHMIType);\n        return this;\n    }\n\n    /**\n    * @return {Array<AppHMIType>}\n    */\n    getAppHmiType () {\n        return this.getObject(AppHMIType, RegisterAppInterface.KEY_APP_HMI_TYPE);\n    }\n\n    /**\n    * @param {String} hashID the hash ID\n    * @return {RegisterAppInterface}\n    */\n    setHashID (hashID) {\n        this.validateType(String, hashID);\n\n        this.setParameter(RegisterAppInterface.KEY_HASH_ID, hashID);\n        return this;\n    }\n\n    /**\n    * @return {String} the hash ID\n    */\n    getHashID () {\n        return this.getParameter(RegisterAppInterface.KEY_HASH_ID);\n    }\n\n    /**\n     * @param {DeviceInfo} deviceInfo\n     * @return {RegisterAppInterface}\n     */\n    setDeviceInfo (deviceInfo) {\n        this.validateType(DeviceInfo, deviceInfo);\n\n        this.setParameter(RegisterAppInterface.KEY_DEVICE_INFO, deviceInfo);\n        return this;\n    }\n\n    /**\n    * @return {DeviceInfo}\n    */\n    getDeviceInfo () {\n        return this.getObject(DeviceInfo, RegisterAppInterface.KEY_DEVICE_INFO);\n    }\n\n\n    /**\n    * @param {String} appName This method should not be accessed directly by developers. Only set the full ID and this param will be set.\n    * @return {RegisterAppInterface}\n    */\n    _setAppId (appId) {\n        this.validateType(String, appId);\n\n        this.setParameter(RegisterAppInterface.KEY_APP_ID, appId);\n        return this;\n    }\n\n    /**\n    * @return {String} the app id\n    */\n    getAppId () {\n        return this.getParameter(RegisterAppInterface.KEY_APP_ID);\n    }\n\n    /**\n    * @param {String} fullAppId\n    * @return {RegisterAppInterface}\n    */\n    setFullAppId (fullAppId) {\n        this.validateType(String, fullAppId);\n\n        if (fullAppId !== null) {\n            fullAppId = fullAppId.toLowerCase();\n            this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, fullAppId);\n            let appId;\n            if (fullAppId.length <= RegisterAppInterface.APP_ID_MAX_LENGTH) {\n                appId = fullAppId;\n            } else {\n                appId = fullAppId.replace('-', '').substring(0, RegisterAppInterface.APP_ID_MAX_LENGTH);\n            }\n            this._setAppId(appId);\n        } else {\n            this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, null);\n        }\n\n        return this;\n    }\n\n    /**\n    * @return {String} the app id\n    */\n    getFullAppId () {\n        return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID);\n    }\n\n\n    /**\n     * @param {AppInfo} appInfo\n     * @return {RegisterAppInterface}\n     */\n    setAppInfo (appInfo) {\n        this.validateType(AppInfo, appInfo);\n\n        this.setParameter(RegisterAppInterface.KEY_APP_INFO, appInfo);\n        return this;\n    }\n\n    /**\n    * @return {AppInfo}\n    */\n    getAppInfo () {\n        return this.getObject(AppInfo, RegisterAppInterface.KEY_APP_INFO);\n    }\n\n    /**\n     * @param {TemplateColorScheme} dayColorScheme\n     * @return {RegisterAppInterface}\n     */\n    setDayColorScheme (dayColorScheme) {\n        this.validateType(TemplateColorScheme, dayColorScheme);\n\n        this.setParameter(RegisterAppInterface.KEY_DAY_COLOR_SCHEME, dayColorScheme);\n        return this;\n    }\n\n    /**\n    * @return {TemplateColorScheme}\n    */\n    getDayColorScheme () {\n        return this.getObject(TemplateColorScheme, RegisterAppInterface.KEY_DAY_COLOR_SCHEME);\n    }\n\n    /**\n     * @param {TemplateColorScheme} nightColorScheme\n     * @return {RegisterAppInterface}\n     */\n    setNightColorScheme (nightColorScheme) {\n        this.validateType(TemplateColorScheme, nightColorScheme);\n\n        this.setParameter(RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME, nightColorScheme);\n        return this;\n    }\n\n    /**\n    * @return {TemplateColorScheme}\n    */\n    getNightColorScheme () {\n        return this.getObject(TemplateColorScheme, RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME);\n    }\n}\n\nRegisterAppInterface.KEY_SYNC_MSG_VERSION = 'syncMsgVersion';\nRegisterAppInterface.KEY_SDL_MSG_VERSION = 'syncMsgVersion';\nRegisterAppInterface.KEY_APP_NAME = 'appName';\nRegisterAppInterface.KEY_TTS_NAME = 'ttsName';\nRegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME = 'ngnMediaScreenAppName';\nRegisterAppInterface.KEY_VR_SYNONYMS = 'vrSynonyms';\nRegisterAppInterface.KEY_IS_MEDIA_APPLICATION = 'isMediaApplication';\nRegisterAppInterface.KEY_LANGUAGE_DESIRED = 'languageDesired';\nRegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED = 'hmiDisplayLanguageDesired';\nRegisterAppInterface.KEY_APP_HMI_TYPE = 'appHMIType';\nRegisterAppInterface.KEY_HASH_ID = 'hashID';\nRegisterAppInterface.KEY_DEVICE_INFO = 'deviceInfo';\nRegisterAppInterface.KEY_APP_ID = 'appID';\nRegisterAppInterface.KEY_FULL_APP_ID = 'fullAppID';\nRegisterAppInterface.KEY_APP_INFO = 'appInfo';\nRegisterAppInterface.KEY_DAY_COLOR_SCHEME = 'dayColorScheme';\nRegisterAppInterface.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme';\nRegisterAppInterface.APP_ID_MAX_LENGTH = 10;\n\nexport { RegisterAppInterface };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} Result\n * @property {Object} _MAP\n */\nclass Result extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SUCCESS () {\n        return Result._MAP.SUCCESS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UNSUPPORTED_REQUEST () {\n        return Result._MAP.UNSUPPORTED_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UNSUPPORTED_RESOURCE () {\n        return Result._MAP.UNSUPPORTED_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DISALLOWED () {\n        return Result._MAP.DISALLOWED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REJECTED () {\n        return Result._MAP.REJECTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ABORTED () {\n        return Result._MAP.ABORTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IGNORED () {\n        return Result._MAP.IGNORED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RETRY () {\n        return Result._MAP.RETRY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IN_USE () {\n        return Result._MAP.IN_USE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLE_DATA_NOT_AVAILABLE () {\n        return Result._MAP.VEHICLE_DATA_NOT_AVAILABLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TIMED_OUT () {\n        return Result._MAP.TIMED_OUT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INVALID_DATA () {\n        return Result._MAP.INVALID_DATA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CHAR_LIMIT_EXCEEDED () {\n        return Result._MAP.CHAR_LIMIT_EXCEEDED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INVALID_ID () {\n        return Result._MAP.INVALID_ID;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DUPLICATE_NAME () {\n        return Result._MAP.DUPLICATE_NAME;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get APPLICATION_NOT_REGISTERED () {\n        return Result._MAP.APPLICATION_NOT_REGISTERED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WRONG_LANGUAGE () {\n        return Result._MAP.WRONG_LANGUAGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OUT_OF_MEMORY () {\n        return Result._MAP.OUT_OF_MEMORY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TOO_MANY_PENDING_REQUESTS () {\n        return Result._MAP.TOO_MANY_PENDING_REQUESTS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TOO_MANY_APPLICATIONS () {\n        return Result._MAP.TOO_MANY_APPLICATIONS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get APPLICATION_REGISTERED_ALREADY () {\n        return Result._MAP.APPLICATION_REGISTERED_ALREADY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WARNINGS () {\n        return Result._MAP.WARNINGS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GENERIC_ERROR () {\n        return Result._MAP.GENERIC_ERROR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get USER_DISALLOWED () {\n        return Result._MAP.USER_DISALLOWED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TRUNCATED_DATA () {\n        return Result._MAP.TRUNCATED_DATA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UNSUPPORTED_VERSION () {\n        return Result._MAP.UNSUPPORTED_VERSION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLE_DATA_NOT_ALLOWED () {\n        return Result._MAP.VEHICLE_DATA_NOT_ALLOWED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FILE_NOT_FOUND () {\n        return Result._MAP.FILE_NOT_FOUND;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CANCEL_ROUTE () {\n        return Result._MAP.CANCEL_ROUTE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SAVED () {\n        return Result._MAP.SAVED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INVALID_CERT () {\n        return Result._MAP.INVALID_CERT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EXPIRED_CERT () {\n        return Result._MAP.EXPIRED_CERT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RESUME_FAILED () {\n        return Result._MAP.RESUME_FAILED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DATA_NOT_AVAILABLE () {\n        return Result._MAP.DATA_NOT_AVAILABLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get READ_ONLY () {\n        return Result._MAP.READ_ONLY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CORRUPTED_DATA () {\n        return Result._MAP.CORRUPTED_DATA;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return Result._valueForKey(key, Result._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return Result._keyForValue(value, Result._MAP);\n    }\n}\n\nResult._MAP = Object.freeze({\n    'SUCCESS': 'SUCCESS',\n    'UNSUPPORTED_REQUEST': 'UNSUPPORTED_REQUEST',\n    'UNSUPPORTED_RESOURCE': 'UNSUPPORTED_RESOURCE',\n    'DISALLOWED': 'DISALLOWED',\n    'REJECTED': 'REJECTED',\n    'ABORTED': 'ABORTED',\n    'IGNORED': 'IGNORED',\n    'RETRY': 'RETRY',\n    'IN_USE': 'IN_USE',\n    'VEHICLE_DATA_NOT_AVAILABLE': 'VEHICLE_DATA_NOT_AVAILABLE',\n    'TIMED_OUT': 'TIMED_OUT',\n    'INVALID_DATA': 'INVALID_DATA',\n    'CHAR_LIMIT_EXCEEDED': 'CHAR_LIMIT_EXCEEDED',\n    'INVALID_ID': 'INVALID_ID',\n    'DUPLICATE_NAME': 'DUPLICATE_NAME',\n    'APPLICATION_NOT_REGISTERED': 'APPLICATION_NOT_REGISTERED',\n    'WRONG_LANGUAGE': 'WRONG_LANGUAGE',\n    'OUT_OF_MEMORY': 'OUT_OF_MEMORY',\n    'TOO_MANY_PENDING_REQUESTS': 'TOO_MANY_PENDING_REQUESTS',\n    'TOO_MANY_APPLICATIONS': 'TOO_MANY_APPLICATIONS',\n    'APPLICATION_REGISTERED_ALREADY': 'APPLICATION_REGISTERED_ALREADY',\n    'WARNINGS': 'WARNINGS',\n    'GENERIC_ERROR': 'GENERIC_ERROR',\n    'USER_DISALLOWED': 'USER_DISALLOWED',\n    'TRUNCATED_DATA': 'TRUNCATED_DATA',\n    'UNSUPPORTED_VERSION': 'UNSUPPORTED_VERSION',\n    'VEHICLE_DATA_NOT_ALLOWED': 'VEHICLE_DATA_NOT_ALLOWED',\n    'FILE_NOT_FOUND': 'FILE_NOT_FOUND',\n    'CANCEL_ROUTE': 'CANCEL_ROUTE',\n    'SAVED': 'SAVED',\n    'INVALID_CERT': 'INVALID_CERT',\n    'EXPIRED_CERT': 'EXPIRED_CERT',\n    'RESUME_FAILED': 'RESUME_FAILED',\n    'DATA_NOT_AVAILABLE': 'DATA_NOT_AVAILABLE',\n    'READ_ONLY': 'READ_ONLY',\n    'CORRUPTED_DATA': 'CORRUPTED_DATA',\n});\n\nexport { Result };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcMessage } from './RpcMessage.js';\nimport { RpcType } from './enums/RpcType.js';\nimport { Result } from './enums/Result.js';\n\nclass RpcResponse extends RpcMessage {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setRPCType(RpcType.RESPONSE);\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getSuccess () {\n        return this.getParameter(RpcResponse.KEY_SUCCESS);\n    }\n\n    /**\n    * @return {RpcResponse}\n    */\n    setSuccess (success) {\n        this.setParameter(RpcResponse.KEY_SUCCESS, success);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getInfo () {\n        return this.getParameter(RpcResponse.KEY_INFO);\n    }\n\n    /**\n    * @return {RpcResponse}\n    */\n    setInfo (info) {\n        this.setParameter(RpcResponse.KEY_INFO, info);\n        return this;\n    }\n\n    /**\n    * @return {Result}\n    */\n    getResultCode () {\n        return this.getObject(Result, RpcResponse.KEY_RESULT_CODE);\n    }\n\n    /**\n    * @return {RpcResponse}\n    */\n    setResultCode (resultCode) {\n        this.validateType(Result, resultCode);\n\n        this.setParameter(RpcResponse.KEY_RESULT_CODE, resultCode);\n        return this;\n    }\n}\n\nRpcResponse.KEY_SUCCESS     = 'success';\nRpcResponse.KEY_INFO        = 'info';\nRpcResponse.KEY_RESULT_CODE = 'resultCode';\n\nexport { RpcResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass RpcListener {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this._onRpcMessage = null;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {RpcListener}\n     */\n    setOnRpcMessage (func) {\n        this._onRpcMessage = func;\n\n        return this;\n    }\n\n    /**\n     *\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessage (rpcMessage) {\n        if (typeof this._onRpcMessage === 'function') {\n            this._onRpcMessage(rpcMessage);\n        }\n    }\n}\n\nexport { RpcListener };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} SdlProtocolListener\n * @property {function} setOnRpcMessageReceived\n * @property {function} onRpcMessageReceived\n * @property {function} setOnProtocolSessionStarted\n * @property {function} onProtocolSessionStarted\n * @property {function} setOnProtocolSessionEnded\n * @property {function} onProtocolSessionEnded\n * @property {function} setOnProtocolSessionEndedNACKed\n * @property {function} onProtocolSessionEndedNACKed\n * @property {function} setGetSessionId\n * @property {function} getSessionId\n */\nclass SdlProtocolListener {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this._onRpcMessageReceived = null;\n        this._onProtocolSessionStarted = null;\n        this._onProtocolSessionEnded = null;\n        this._onProtocolSessionEndedNACKed = null;\n        this._getSessionId = null;\n        this._onTransportConnected = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnTransportConnected (listener) {\n        this._onTransportConnected = listener;\n        return this;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnRpcMessageReceived (listener) {\n        this._onRpcMessageReceived = listener;\n        return this;\n    }\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessageReceived (rpcMessage) {\n        if (typeof this._onRpcMessageReceived === 'function') {\n            this._onRpcMessageReceived(rpcMessage);\n        }\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionStarted (listener) {\n        this._onProtocolSessionStarted = listener;\n        return this;\n    }\n\n\n    onTransportConnected () {\n        if (typeof this._onTransportConnected === 'function') {\n            this._onTransportConnected();\n        }\n    }\n\n    /**\n     * Invoke the onProtocolSessionStarted listener with the event data\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {Number} version\n     * @param {String} correlationId\n     * @param {Number} hashId\n     * @param {Boolean} isEncrypted\n     */\n    onProtocolSessionStarted (serviceType, sessionId, version, correlationId, hashId, isEncrypted) {\n        if (typeof this._onProtocolSessionStarted === 'function') {\n            this._onProtocolSessionStarted(serviceType, sessionId, version, correlationId, hashId, isEncrypted);\n        }\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEnded (listener) {\n        this._onProtocolSessionEnded = listener;\n        return this;\n    }\n\n    /**\n     * Invoke the onProtocolSessionEnded listener with the event data\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {String} correlationId\n     */\n    onProtocolSessionEnded (serviceType, sessionId, correlationId) {\n        if (typeof this._onProtocolSessionEnded === 'function') {\n            this._onProtocolSessionEnded(serviceType, sessionId, correlationId);\n        }\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEndedNACKed (listener) {\n        this._onProtocolSessionEndedNACKed = listener;\n        return this;\n    }\n\n    /**\n     * Invoke the onProtocolSessionEndedNACKed listener with the event data\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {String} correlationId\n     */\n    onProtocolSessionEndedNACKed (serviceType, sessionId, correlationId) {\n        if (typeof this._onProtocolSessionEndedNACKed === 'function') {\n            this._onProtocolSessionEndedNACKed(serviceType, sessionId, correlationId);\n        }\n    }\n\n    /**\n     * @param {function} getter\n     */\n    setGetSessionId (getter) {\n        this._getSessionId = getter;\n        return this;\n    }\n\n    /**\n     * Invoke the getSessionId getter\n     * @returns {Number} sessionId\n     */\n    getSessionId () {\n        if (typeof this._getSessionId === 'function') {\n            return this._getSessionId();\n        }\n    }\n\n\n    /**\n     * Sets the getDesiredVideoParams getter\n     * @param {function} getter\n     */\n    setGetDesiredVideoParams (getter) {\n        this._getDesiredVideoParams = getter;\n        return this;\n    }\n\n    /**\n     * Invoke the getDesiredVideoParams getter\n     * @returns {VideoStreamingParameters}\n     */\n    getDesiredVideoParams () {\n        if (typeof this._getDesiredVideoParams === 'function') {\n            return this._getDesiredVideoParams();\n        }\n    }\n\n    /**\n     * Sets the setSetAcceptedVideoParams setter\n     * @param {function} setter\n     */\n    setSetAcceptedVideoParams (setter) {\n        this._setAcceptedVideoParams = setter;\n        return this;\n    }\n\n\n    /**\n     * Invoke the setAcceptedVideoParams setter\n     * @param {VideoStreamingParameters} params\n     */\n    setAcceptedVideoParams (params) {\n        if (typeof this._setAcceptedVideoParams === 'function') {\n            this._setAcceptedVideoParams(params);\n        }\n        return this;\n    }\n}\n\nexport { SdlProtocolListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} FrameType\n * @property {Object} _MAP\n */\nclass FrameType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CONTROL () {\n        return FrameType._MAP.CONTROL;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get FIRST () {\n        return FrameType._MAP.FIRST;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CONSECUTIVE () {\n        return FrameType._MAP.CONSECUTIVE;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SINGLE () {\n        return FrameType._MAP.SINGLE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return FrameType._valueForKey(key, FrameType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return FrameType._keyForValue(value, FrameType._MAP);\n    }\n}\n\nFrameType._MAP = Object.freeze({\n    'CONTROL': 0x00,\n    'FIRST': 0x02,\n    'CONSECUTIVE': 0x03,\n    'SINGLE': 0x01,\n});\n\nexport { FrameType };\n","exports[\"bson\"] =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 2);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\nvar g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\n} catch(e) {\n\t// This works if the window reference is available\n\tif(typeof window === \"object\")\n\t\tg = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n\n\nvar base64 = __webpack_require__(3)\nvar ieee754 = __webpack_require__(4)\nvar isArray = __webpack_require__(5)\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, Buffer) {(function (global, factory) {\n\t true ? factory(exports, __webpack_require__(6), __webpack_require__(1)) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'long', 'buffer'], factory) :\n\t(factory((global.BSON = {}),global.long,global.Buffer));\n}(this, (function (exports,long,buffer) { 'use strict';\n\n\tlong = long && long.hasOwnProperty('default') ? long['default'] : long;\n\tbuffer = buffer && buffer.hasOwnProperty('default') ? buffer['default'] : buffer;\n\n\tvar commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\n\tfunction createCommonjsModule(fn, module) {\n\t\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n\t}\n\n\tfunction getCjsExportFromNamespace (n) {\n\t\treturn n && n.default || n;\n\t}\n\n\tvar map = createCommonjsModule(function (module) {\n\n\t  if (typeof commonjsGlobal.Map !== 'undefined') {\n\t    module.exports = commonjsGlobal.Map;\n\t    module.exports.Map = commonjsGlobal.Map;\n\t  } else {\n\t    // We will return a polyfill\n\t    var Map = function Map(array) {\n\t      this._keys = [];\n\t      this._values = {};\n\n\t      for (var i = 0; i < array.length; i++) {\n\t        if (array[i] == null) continue; // skip null and undefined\n\n\t        var entry = array[i];\n\t        var key = entry[0];\n\t        var value = entry[1]; // Add the key to the list of keys in order\n\n\t        this._keys.push(key); // Add the key and value to the values dictionary with a point\n\t        // to the location in the ordered keys list\n\n\n\t        this._values[key] = {\n\t          v: value,\n\t          i: this._keys.length - 1\n\t        };\n\t      }\n\t    };\n\n\t    Map.prototype.clear = function () {\n\t      this._keys = [];\n\t      this._values = {};\n\t    };\n\n\t    Map.prototype.delete = function (key) {\n\t      var value = this._values[key];\n\t      if (value == null) return false; // Delete entry\n\n\t      delete this._values[key]; // Remove the key from the ordered keys list\n\n\t      this._keys.splice(value.i, 1);\n\n\t      return true;\n\t    };\n\n\t    Map.prototype.entries = function () {\n\t      var self = this;\n\t      var index = 0;\n\t      return {\n\t        next: function next() {\n\t          var key = self._keys[index++];\n\t          return {\n\t            value: key !== undefined ? [key, self._values[key].v] : undefined,\n\t            done: key !== undefined ? false : true\n\t          };\n\t        }\n\t      };\n\t    };\n\n\t    Map.prototype.forEach = function (callback, self) {\n\t      self = self || this;\n\n\t      for (var i = 0; i < this._keys.length; i++) {\n\t        var key = this._keys[i]; // Call the forEach callback\n\n\t        callback.call(self, this._values[key].v, key, self);\n\t      }\n\t    };\n\n\t    Map.prototype.get = function (key) {\n\t      return this._values[key] ? this._values[key].v : undefined;\n\t    };\n\n\t    Map.prototype.has = function (key) {\n\t      return this._values[key] != null;\n\t    };\n\n\t    Map.prototype.keys = function () {\n\t      var self = this;\n\t      var index = 0;\n\t      return {\n\t        next: function next() {\n\t          var key = self._keys[index++];\n\t          return {\n\t            value: key !== undefined ? key : undefined,\n\t            done: key !== undefined ? false : true\n\t          };\n\t        }\n\t      };\n\t    };\n\n\t    Map.prototype.set = function (key, value) {\n\t      if (this._values[key]) {\n\t        this._values[key].v = value;\n\t        return this;\n\t      } // Add the key to the list of keys in order\n\n\n\t      this._keys.push(key); // Add the key and value to the values dictionary with a point\n\t      // to the location in the ordered keys list\n\n\n\t      this._values[key] = {\n\t        v: value,\n\t        i: this._keys.length - 1\n\t      };\n\t      return this;\n\t    };\n\n\t    Map.prototype.values = function () {\n\t      var self = this;\n\t      var index = 0;\n\t      return {\n\t        next: function next() {\n\t          var key = self._keys[index++];\n\t          return {\n\t            value: key !== undefined ? self._values[key].v : undefined,\n\t            done: key !== undefined ? false : true\n\t          };\n\t        }\n\t      };\n\t    }; // Last ismaster\n\n\n\t    Object.defineProperty(Map.prototype, 'size', {\n\t      enumerable: true,\n\t      get: function get() {\n\t        return this._keys.length;\n\t      }\n\t    });\n\t    module.exports = Map;\n\t  }\n\t});\n\tvar map_1 = map.Map;\n\n\t/**\n\t * @ignore\n\t */\n\n\n\tlong.prototype.toExtendedJSON = function (options) {\n\t  if (options && options.relaxed) return this.toNumber();\n\t  return {\n\t    $numberLong: this.toString()\n\t  };\n\t};\n\t/**\n\t * @ignore\n\t */\n\n\n\tlong.fromExtendedJSON = function (doc, options) {\n\t  var result = long.fromString(doc.$numberLong);\n\t  return options && options.relaxed ? result.toNumber() : result;\n\t};\n\n\tObject.defineProperty(long.prototype, '_bsontype', {\n\t  value: 'Long'\n\t});\n\tvar long_1 = long;\n\n\t/**\n\t * A class representation of the BSON Double type.\n\t */\n\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n\tvar Double =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Double type\n\t   *\n\t   * @param {number} value the number we want to represent as a double.\n\t   * @return {Double}\n\t   */\n\t  function Double(value) {\n\t    _classCallCheck(this, Double);\n\n\t    this.value = value;\n\t  }\n\t  /**\n\t   * Access the number value.\n\t   *\n\t   * @method\n\t   * @return {number} returns the wrapped double number.\n\t   */\n\n\n\t  _createClass(Double, [{\n\t    key: \"valueOf\",\n\t    value: function valueOf() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON(options) {\n\t      if (options && options.relaxed && isFinite(this.value)) return this.value;\n\t      return {\n\t        $numberDouble: this.value.toString()\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc, options) {\n\t      return options && options.relaxed ? parseFloat(doc.$numberDouble) : new Double(parseFloat(doc.$numberDouble));\n\t    }\n\t  }]);\n\n\t  return Double;\n\t}();\n\n\tObject.defineProperty(Double.prototype, '_bsontype', {\n\t  value: 'Double'\n\t});\n\tvar double_1 = Double;\n\n\tfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n\tfunction _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }\n\n\tfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\n\tfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\n\tfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\n\tfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\t/**\n\t * @class\n\t * @param {number} low  the low (signed) 32 bits of the Timestamp.\n\t * @param {number} high the high (signed) 32 bits of the Timestamp.\n\t * @return {Timestamp}\n\t */\n\n\n\tvar Timestamp =\n\t/*#__PURE__*/\n\tfunction (_Long) {\n\t  _inherits(Timestamp, _Long);\n\n\t  function Timestamp(low, high) {\n\t    var _this;\n\n\t    _classCallCheck$1(this, Timestamp);\n\n\t    if (long_1.isLong(low)) {\n\t      _this = _possibleConstructorReturn(this, _getPrototypeOf(Timestamp).call(this, low.low, low.high));\n\t    } else {\n\t      _this = _possibleConstructorReturn(this, _getPrototypeOf(Timestamp).call(this, low, high));\n\t    }\n\n\t    return _possibleConstructorReturn(_this);\n\t  }\n\t  /**\n\t   * Return the JSON value.\n\t   *\n\t   * @method\n\t   * @return {String} the JSON representation.\n\t   */\n\n\n\t  _createClass$1(Timestamp, [{\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return {\n\t        $timestamp: this.toString()\n\t      };\n\t    }\n\t    /**\n\t     * Returns a Timestamp represented by the given (32-bit) integer value.\n\t     *\n\t     * @method\n\t     * @param {number} value the 32-bit integer in question.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\n\t    /**\n\t     * @ignore\n\t     */\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $timestamp: {\n\t          t: this.high,\n\t          i: this.low\n\t        }\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromInt\",\n\t    value: function fromInt(value) {\n\t      return new Timestamp(long_1.fromInt(value));\n\t    }\n\t    /**\n\t     * Returns a Timestamp representing the given number value, provided that it is a finite number. Otherwise, zero is returned.\n\t     *\n\t     * @method\n\t     * @param {number} value the number in question.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"fromNumber\",\n\t    value: function fromNumber(value) {\n\t      return new Timestamp(long_1.fromNumber(value));\n\t    }\n\t    /**\n\t     * Returns a Timestamp for the given high and low bits. Each is assumed to use 32 bits.\n\t     *\n\t     * @method\n\t     * @param {number} lowBits the low 32-bits.\n\t     * @param {number} highBits the high 32-bits.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"fromBits\",\n\t    value: function fromBits(lowBits, highBits) {\n\t      return new Timestamp(lowBits, highBits);\n\t    }\n\t    /**\n\t     * Returns a Timestamp from the given string, optionally using the given radix.\n\t     *\n\t     * @method\n\t     * @param {String} str the textual representation of the Timestamp.\n\t     * @param {number} [opt_radix] the radix in which the text is written.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"fromString\",\n\t    value: function fromString(str, opt_radix) {\n\t      return new Timestamp(long_1.fromString(str, opt_radix));\n\t    }\n\t  }, {\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new Timestamp(doc.$timestamp.i, doc.$timestamp.t);\n\t    }\n\t  }]);\n\n\t  return Timestamp;\n\t}(long_1);\n\n\tObject.defineProperty(Timestamp.prototype, '_bsontype', {\n\t  value: 'Timestamp'\n\t});\n\tvar timestamp = Timestamp;\n\n\tvar empty = {};\n\n\tvar empty$1 = /*#__PURE__*/Object.freeze({\n\t\tdefault: empty\n\t});\n\n\tvar require$$0 = getCjsExportFromNamespace(empty$1);\n\n\t/* global window */\n\n\t/**\n\t * Normalizes our expected stringified form of a function across versions of node\n\t * @param {Function} fn The function to stringify\n\t */\n\n\n\tfunction normalizedFunctionString(fn) {\n\t  return fn.toString().replace('function(', 'function (');\n\t}\n\n\tfunction insecureRandomBytes(size) {\n\t  var result = new Uint8Array(size);\n\n\t  for (var i = 0; i < size; ++i) {\n\t    result[i] = Math.floor(Math.random() * 256);\n\t  }\n\n\t  return result;\n\t}\n\n\tvar randomBytes = insecureRandomBytes;\n\n\tif (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {\n\t  randomBytes = function randomBytes(size) {\n\t    return window.crypto.getRandomValues(new Uint8Array(size));\n\t  };\n\t} else {\n\t  try {\n\t    randomBytes = require$$0.randomBytes;\n\t  } catch (e) {} // keep the fallback\n\t  // NOTE: in transpiled cases the above require might return null/undefined\n\n\n\t  if (randomBytes == null) {\n\t    randomBytes = insecureRandomBytes;\n\t  }\n\t}\n\n\tvar utils = {\n\t  normalizedFunctionString: normalizedFunctionString,\n\t  randomBytes: randomBytes\n\t};\n\n\t// shim for using process in browser\n\t// based off https://github.com/defunctzombie/node-process/blob/master/browser.js\n\tfunction defaultSetTimout() {\n\t  throw new Error('setTimeout has not been defined');\n\t}\n\n\tfunction defaultClearTimeout() {\n\t  throw new Error('clearTimeout has not been defined');\n\t}\n\n\tvar cachedSetTimeout = defaultSetTimout;\n\tvar cachedClearTimeout = defaultClearTimeout;\n\n\tif (typeof global.setTimeout === 'function') {\n\t  cachedSetTimeout = setTimeout;\n\t}\n\n\tif (typeof global.clearTimeout === 'function') {\n\t  cachedClearTimeout = clearTimeout;\n\t}\n\n\tfunction runTimeout(fun) {\n\t  if (cachedSetTimeout === setTimeout) {\n\t    //normal enviroments in sane situations\n\t    return setTimeout(fun, 0);\n\t  } // if setTimeout wasn't available but was latter defined\n\n\n\t  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n\t    cachedSetTimeout = setTimeout;\n\t    return setTimeout(fun, 0);\n\t  }\n\n\t  try {\n\t    // when when somebody has screwed with setTimeout but no I.E. maddness\n\t    return cachedSetTimeout(fun, 0);\n\t  } catch (e) {\n\t    try {\n\t      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t      return cachedSetTimeout.call(null, fun, 0);\n\t    } catch (e) {\n\t      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n\t      return cachedSetTimeout.call(this, fun, 0);\n\t    }\n\t  }\n\t}\n\n\tfunction runClearTimeout(marker) {\n\t  if (cachedClearTimeout === clearTimeout) {\n\t    //normal enviroments in sane situations\n\t    return clearTimeout(marker);\n\t  } // if clearTimeout wasn't available but was latter defined\n\n\n\t  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n\t    cachedClearTimeout = clearTimeout;\n\t    return clearTimeout(marker);\n\t  }\n\n\t  try {\n\t    // when when somebody has screwed with setTimeout but no I.E. maddness\n\t    return cachedClearTimeout(marker);\n\t  } catch (e) {\n\t    try {\n\t      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n\t      return cachedClearTimeout.call(null, marker);\n\t    } catch (e) {\n\t      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n\t      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n\t      return cachedClearTimeout.call(this, marker);\n\t    }\n\t  }\n\t}\n\n\tvar queue = [];\n\tvar draining = false;\n\tvar currentQueue;\n\tvar queueIndex = -1;\n\n\tfunction cleanUpNextTick() {\n\t  if (!draining || !currentQueue) {\n\t    return;\n\t  }\n\n\t  draining = false;\n\n\t  if (currentQueue.length) {\n\t    queue = currentQueue.concat(queue);\n\t  } else {\n\t    queueIndex = -1;\n\t  }\n\n\t  if (queue.length) {\n\t    drainQueue();\n\t  }\n\t}\n\n\tfunction drainQueue() {\n\t  if (draining) {\n\t    return;\n\t  }\n\n\t  var timeout = runTimeout(cleanUpNextTick);\n\t  draining = true;\n\t  var len = queue.length;\n\n\t  while (len) {\n\t    currentQueue = queue;\n\t    queue = [];\n\n\t    while (++queueIndex < len) {\n\t      if (currentQueue) {\n\t        currentQueue[queueIndex].run();\n\t      }\n\t    }\n\n\t    queueIndex = -1;\n\t    len = queue.length;\n\t  }\n\n\t  currentQueue = null;\n\t  draining = false;\n\t  runClearTimeout(timeout);\n\t}\n\n\tfunction nextTick(fun) {\n\t  var args = new Array(arguments.length - 1);\n\n\t  if (arguments.length > 1) {\n\t    for (var i = 1; i < arguments.length; i++) {\n\t      args[i - 1] = arguments[i];\n\t    }\n\t  }\n\n\t  queue.push(new Item(fun, args));\n\n\t  if (queue.length === 1 && !draining) {\n\t    runTimeout(drainQueue);\n\t  }\n\t} // v8 likes predictible objects\n\n\tfunction Item(fun, array) {\n\t  this.fun = fun;\n\t  this.array = array;\n\t}\n\n\tItem.prototype.run = function () {\n\t  this.fun.apply(null, this.array);\n\t};\n\n\tvar title = 'browser';\n\tvar platform = 'browser';\n\tvar browser = true;\n\tvar env = {};\n\tvar argv = [];\n\tvar version = ''; // empty string to avoid regexp issues\n\n\tvar versions = {};\n\tvar release = {};\n\tvar config = {};\n\n\tfunction noop() {}\n\n\tvar on = noop;\n\tvar addListener = noop;\n\tvar once = noop;\n\tvar off = noop;\n\tvar removeListener = noop;\n\tvar removeAllListeners = noop;\n\tvar emit = noop;\n\tfunction binding(name) {\n\t  throw new Error('process.binding is not supported');\n\t}\n\tfunction cwd() {\n\t  return '/';\n\t}\n\tfunction chdir(dir) {\n\t  throw new Error('process.chdir is not supported');\n\t}\n\tfunction umask() {\n\t  return 0;\n\t} // from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\n\n\tvar performance = global.performance || {};\n\n\tvar performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function () {\n\t  return new Date().getTime();\n\t}; // generate timestamp or delta\n\t// see http://nodejs.org/api/process.html#process_process_hrtime\n\n\n\tfunction hrtime(previousTimestamp) {\n\t  var clocktime = performanceNow.call(performance) * 1e-3;\n\t  var seconds = Math.floor(clocktime);\n\t  var nanoseconds = Math.floor(clocktime % 1 * 1e9);\n\n\t  if (previousTimestamp) {\n\t    seconds = seconds - previousTimestamp[0];\n\t    nanoseconds = nanoseconds - previousTimestamp[1];\n\n\t    if (nanoseconds < 0) {\n\t      seconds--;\n\t      nanoseconds += 1e9;\n\t    }\n\t  }\n\n\t  return [seconds, nanoseconds];\n\t}\n\tvar startTime = new Date();\n\tfunction uptime() {\n\t  var currentTime = new Date();\n\t  var dif = currentTime - startTime;\n\t  return dif / 1000;\n\t}\n\tvar process = {\n\t  nextTick: nextTick,\n\t  title: title,\n\t  browser: browser,\n\t  env: env,\n\t  argv: argv,\n\t  version: version,\n\t  versions: versions,\n\t  on: on,\n\t  addListener: addListener,\n\t  once: once,\n\t  off: off,\n\t  removeListener: removeListener,\n\t  removeAllListeners: removeAllListeners,\n\t  emit: emit,\n\t  binding: binding,\n\t  cwd: cwd,\n\t  chdir: chdir,\n\t  umask: umask,\n\t  hrtime: hrtime,\n\t  platform: platform,\n\t  release: release,\n\t  config: config,\n\t  uptime: uptime\n\t};\n\n\tvar inherits;\n\n\tif (typeof Object.create === 'function') {\n\t  inherits = function inherits(ctor, superCtor) {\n\t    // implementation from standard node.js 'util' module\n\t    ctor.super_ = superCtor;\n\t    ctor.prototype = Object.create(superCtor.prototype, {\n\t      constructor: {\n\t        value: ctor,\n\t        enumerable: false,\n\t        writable: true,\n\t        configurable: true\n\t      }\n\t    });\n\t  };\n\t} else {\n\t  inherits = function inherits(ctor, superCtor) {\n\t    ctor.super_ = superCtor;\n\n\t    var TempCtor = function TempCtor() {};\n\n\t    TempCtor.prototype = superCtor.prototype;\n\t    ctor.prototype = new TempCtor();\n\t    ctor.prototype.constructor = ctor;\n\t  };\n\t}\n\n\tvar inherits$1 = inherits;\n\n\tfunction _typeof$1(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$1(obj); }\n\tvar formatRegExp = /%[sdj%]/g;\n\tfunction format(f) {\n\t  if (!isString(f)) {\n\t    var objects = [];\n\n\t    for (var i = 0; i < arguments.length; i++) {\n\t      objects.push(inspect(arguments[i]));\n\t    }\n\n\t    return objects.join(' ');\n\t  }\n\n\t  var i = 1;\n\t  var args = arguments;\n\t  var len = args.length;\n\t  var str = String(f).replace(formatRegExp, function (x) {\n\t    if (x === '%%') return '%';\n\t    if (i >= len) return x;\n\n\t    switch (x) {\n\t      case '%s':\n\t        return String(args[i++]);\n\n\t      case '%d':\n\t        return Number(args[i++]);\n\n\t      case '%j':\n\t        try {\n\t          return JSON.stringify(args[i++]);\n\t        } catch (_) {\n\t          return '[Circular]';\n\t        }\n\n\t      default:\n\t        return x;\n\t    }\n\t  });\n\n\t  for (var x = args[i]; i < len; x = args[++i]) {\n\t    if (isNull(x) || !isObject(x)) {\n\t      str += ' ' + x;\n\t    } else {\n\t      str += ' ' + inspect(x);\n\t    }\n\t  }\n\n\t  return str;\n\t}\n\t// Returns a modified function which warns once by default.\n\t// If --no-deprecation is set, then it is a no-op.\n\n\tfunction deprecate(fn, msg) {\n\t  // Allow for deprecating things in the process of starting up.\n\t  if (isUndefined(global.process)) {\n\t    return function () {\n\t      return deprecate(fn, msg).apply(this, arguments);\n\t    };\n\t  }\n\n\t  var warned = false;\n\n\t  function deprecated() {\n\t    if (!warned) {\n\t      {\n\t        console.error(msg);\n\t      }\n\n\t      warned = true;\n\t    }\n\n\t    return fn.apply(this, arguments);\n\t  }\n\n\t  return deprecated;\n\t}\n\tvar debugs = {};\n\tvar debugEnviron;\n\tfunction debuglog(set) {\n\t  if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';\n\t  set = set.toUpperCase();\n\n\t  if (!debugs[set]) {\n\t    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n\t      var pid = 0;\n\n\t      debugs[set] = function () {\n\t        var msg = format.apply(null, arguments);\n\t        console.error('%s %d: %s', set, pid, msg);\n\t      };\n\t    } else {\n\t      debugs[set] = function () {};\n\t    }\n\t  }\n\n\t  return debugs[set];\n\t}\n\t/**\n\t * Echos the value of a value. Trys to print the value out\n\t * in the best way possible given the different types.\n\t *\n\t * @param {Object} obj The object to print out.\n\t * @param {Object} opts Optional options object that alters the output.\n\t */\n\n\t/* legacy: obj, showHidden, depth, colors*/\n\n\tfunction inspect(obj, opts) {\n\t  // default options\n\t  var ctx = {\n\t    seen: [],\n\t    stylize: stylizeNoColor\n\t  }; // legacy...\n\n\t  if (arguments.length >= 3) ctx.depth = arguments[2];\n\t  if (arguments.length >= 4) ctx.colors = arguments[3];\n\n\t  if (isBoolean(opts)) {\n\t    // legacy...\n\t    ctx.showHidden = opts;\n\t  } else if (opts) {\n\t    // got an \"options\" object\n\t    _extend(ctx, opts);\n\t  } // set default options\n\n\n\t  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n\t  if (isUndefined(ctx.depth)) ctx.depth = 2;\n\t  if (isUndefined(ctx.colors)) ctx.colors = false;\n\t  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n\t  if (ctx.colors) ctx.stylize = stylizeWithColor;\n\t  return formatValue(ctx, obj, ctx.depth);\n\t} // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\n\n\tinspect.colors = {\n\t  'bold': [1, 22],\n\t  'italic': [3, 23],\n\t  'underline': [4, 24],\n\t  'inverse': [7, 27],\n\t  'white': [37, 39],\n\t  'grey': [90, 39],\n\t  'black': [30, 39],\n\t  'blue': [34, 39],\n\t  'cyan': [36, 39],\n\t  'green': [32, 39],\n\t  'magenta': [35, 39],\n\t  'red': [31, 39],\n\t  'yellow': [33, 39]\n\t}; // Don't use 'blue' not visible on cmd.exe\n\n\tinspect.styles = {\n\t  'special': 'cyan',\n\t  'number': 'yellow',\n\t  'boolean': 'yellow',\n\t  'undefined': 'grey',\n\t  'null': 'bold',\n\t  'string': 'green',\n\t  'date': 'magenta',\n\t  // \"name\": intentionally not styling\n\t  'regexp': 'red'\n\t};\n\n\tfunction stylizeWithColor(str, styleType) {\n\t  var style = inspect.styles[styleType];\n\n\t  if (style) {\n\t    return \"\\x1B[\" + inspect.colors[style][0] + 'm' + str + \"\\x1B[\" + inspect.colors[style][1] + 'm';\n\t  } else {\n\t    return str;\n\t  }\n\t}\n\n\tfunction stylizeNoColor(str, styleType) {\n\t  return str;\n\t}\n\n\tfunction arrayToHash(array) {\n\t  var hash = {};\n\t  array.forEach(function (val, idx) {\n\t    hash[val] = true;\n\t  });\n\t  return hash;\n\t}\n\n\tfunction formatValue(ctx, value, recurseTimes) {\n\t  // Provide a hook for user-specified inspect functions.\n\t  // Check that value is an object with an inspect function on it\n\t  if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special\n\t  value.inspect !== inspect && // Also filter out any prototype objects using the circular check.\n\t  !(value.constructor && value.constructor.prototype === value)) {\n\t    var ret = value.inspect(recurseTimes, ctx);\n\n\t    if (!isString(ret)) {\n\t      ret = formatValue(ctx, ret, recurseTimes);\n\t    }\n\n\t    return ret;\n\t  } // Primitive types cannot have properties\n\n\n\t  var primitive = formatPrimitive(ctx, value);\n\n\t  if (primitive) {\n\t    return primitive;\n\t  } // Look up the keys of the object.\n\n\n\t  var keys = Object.keys(value);\n\t  var visibleKeys = arrayToHash(keys);\n\n\t  if (ctx.showHidden) {\n\t    keys = Object.getOwnPropertyNames(value);\n\t  } // IE doesn't make error fields non-enumerable\n\t  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n\n\n\t  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n\t    return formatError(value);\n\t  } // Some type of object without properties can be shortcutted.\n\n\n\t  if (keys.length === 0) {\n\t    if (isFunction(value)) {\n\t      var name = value.name ? ': ' + value.name : '';\n\t      return ctx.stylize('[Function' + name + ']', 'special');\n\t    }\n\n\t    if (isRegExp(value)) {\n\t      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n\t    }\n\n\t    if (isDate(value)) {\n\t      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n\t    }\n\n\t    if (isError(value)) {\n\t      return formatError(value);\n\t    }\n\t  }\n\n\t  var base = '',\n\t      array = false,\n\t      braces = ['{', '}']; // Make Array say that they are Array\n\n\t  if (isArray(value)) {\n\t    array = true;\n\t    braces = ['[', ']'];\n\t  } // Make functions say that they are functions\n\n\n\t  if (isFunction(value)) {\n\t    var n = value.name ? ': ' + value.name : '';\n\t    base = ' [Function' + n + ']';\n\t  } // Make RegExps say that they are RegExps\n\n\n\t  if (isRegExp(value)) {\n\t    base = ' ' + RegExp.prototype.toString.call(value);\n\t  } // Make dates with properties first say the date\n\n\n\t  if (isDate(value)) {\n\t    base = ' ' + Date.prototype.toUTCString.call(value);\n\t  } // Make error with message first say the error\n\n\n\t  if (isError(value)) {\n\t    base = ' ' + formatError(value);\n\t  }\n\n\t  if (keys.length === 0 && (!array || value.length == 0)) {\n\t    return braces[0] + base + braces[1];\n\t  }\n\n\t  if (recurseTimes < 0) {\n\t    if (isRegExp(value)) {\n\t      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n\t    } else {\n\t      return ctx.stylize('[Object]', 'special');\n\t    }\n\t  }\n\n\t  ctx.seen.push(value);\n\t  var output;\n\n\t  if (array) {\n\t    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n\t  } else {\n\t    output = keys.map(function (key) {\n\t      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n\t    });\n\t  }\n\n\t  ctx.seen.pop();\n\t  return reduceToSingleString(output, base, braces);\n\t}\n\n\tfunction formatPrimitive(ctx, value) {\n\t  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');\n\n\t  if (isString(value)) {\n\t    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '').replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"') + '\\'';\n\t    return ctx.stylize(simple, 'string');\n\t  }\n\n\t  if (isNumber(value)) return ctx.stylize('' + value, 'number');\n\t  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean'); // For some reason typeof null is \"object\", so special case here.\n\n\t  if (isNull(value)) return ctx.stylize('null', 'null');\n\t}\n\n\tfunction formatError(value) {\n\t  return '[' + Error.prototype.toString.call(value) + ']';\n\t}\n\n\tfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n\t  var output = [];\n\n\t  for (var i = 0, l = value.length; i < l; ++i) {\n\t    if (hasOwnProperty(value, String(i))) {\n\t      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));\n\t    } else {\n\t      output.push('');\n\t    }\n\t  }\n\n\t  keys.forEach(function (key) {\n\t    if (!key.match(/^\\d+$/)) {\n\t      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));\n\t    }\n\t  });\n\t  return output;\n\t}\n\n\tfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n\t  var name, str, desc;\n\t  desc = Object.getOwnPropertyDescriptor(value, key) || {\n\t    value: value[key]\n\t  };\n\n\t  if (desc.get) {\n\t    if (desc.set) {\n\t      str = ctx.stylize('[Getter/Setter]', 'special');\n\t    } else {\n\t      str = ctx.stylize('[Getter]', 'special');\n\t    }\n\t  } else {\n\t    if (desc.set) {\n\t      str = ctx.stylize('[Setter]', 'special');\n\t    }\n\t  }\n\n\t  if (!hasOwnProperty(visibleKeys, key)) {\n\t    name = '[' + key + ']';\n\t  }\n\n\t  if (!str) {\n\t    if (ctx.seen.indexOf(desc.value) < 0) {\n\t      if (isNull(recurseTimes)) {\n\t        str = formatValue(ctx, desc.value, null);\n\t      } else {\n\t        str = formatValue(ctx, desc.value, recurseTimes - 1);\n\t      }\n\n\t      if (str.indexOf('\\n') > -1) {\n\t        if (array) {\n\t          str = str.split('\\n').map(function (line) {\n\t            return '  ' + line;\n\t          }).join('\\n').substr(2);\n\t        } else {\n\t          str = '\\n' + str.split('\\n').map(function (line) {\n\t            return '   ' + line;\n\t          }).join('\\n');\n\t        }\n\t      }\n\t    } else {\n\t      str = ctx.stylize('[Circular]', 'special');\n\t    }\n\t  }\n\n\t  if (isUndefined(name)) {\n\t    if (array && key.match(/^\\d+$/)) {\n\t      return str;\n\t    }\n\n\t    name = JSON.stringify('' + key);\n\n\t    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n\t      name = name.substr(1, name.length - 2);\n\t      name = ctx.stylize(name, 'name');\n\t    } else {\n\t      name = name.replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"').replace(/(^\"|\"$)/g, \"'\");\n\t      name = ctx.stylize(name, 'string');\n\t    }\n\t  }\n\n\t  return name + ': ' + str;\n\t}\n\n\tfunction reduceToSingleString(output, base, braces) {\n\t  var length = output.reduce(function (prev, cur) {\n\t    if (cur.indexOf('\\n') >= 0) ;\n\t    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n\t  }, 0);\n\n\t  if (length > 60) {\n\t    return braces[0] + (base === '' ? '' : base + '\\n ') + ' ' + output.join(',\\n  ') + ' ' + braces[1];\n\t  }\n\n\t  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n\t} // NOTE: These type checking functions intentionally don't use `instanceof`\n\t// because it is fragile and can be easily faked with `Object.create()`.\n\n\n\tfunction isArray(ar) {\n\t  return Array.isArray(ar);\n\t}\n\tfunction isBoolean(arg) {\n\t  return typeof arg === 'boolean';\n\t}\n\tfunction isNull(arg) {\n\t  return arg === null;\n\t}\n\tfunction isNullOrUndefined(arg) {\n\t  return arg == null;\n\t}\n\tfunction isNumber(arg) {\n\t  return typeof arg === 'number';\n\t}\n\tfunction isString(arg) {\n\t  return typeof arg === 'string';\n\t}\n\tfunction isSymbol(arg) {\n\t  return _typeof$1(arg) === 'symbol';\n\t}\n\tfunction isUndefined(arg) {\n\t  return arg === void 0;\n\t}\n\tfunction isRegExp(re) {\n\t  return isObject(re) && objectToString(re) === '[object RegExp]';\n\t}\n\tfunction isObject(arg) {\n\t  return _typeof$1(arg) === 'object' && arg !== null;\n\t}\n\tfunction isDate(d) {\n\t  return isObject(d) && objectToString(d) === '[object Date]';\n\t}\n\tfunction isError(e) {\n\t  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);\n\t}\n\tfunction isFunction(arg) {\n\t  return typeof arg === 'function';\n\t}\n\tfunction isPrimitive(arg) {\n\t  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || _typeof$1(arg) === 'symbol' || // ES6 symbol\n\t  typeof arg === 'undefined';\n\t}\n\tfunction isBuffer(maybeBuf) {\n\t  return Buffer.isBuffer(maybeBuf);\n\t}\n\n\tfunction objectToString(o) {\n\t  return Object.prototype.toString.call(o);\n\t}\n\n\tfunction pad(n) {\n\t  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n\t}\n\n\tvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; // 26 Feb 16:19:34\n\n\tfunction timestamp$1() {\n\t  var d = new Date();\n\t  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');\n\t  return [d.getDate(), months[d.getMonth()], time].join(' ');\n\t} // log is just a thin wrapper to console.log that prepends a timestamp\n\n\n\tfunction log() {\n\t  console.log('%s - %s', timestamp$1(), format.apply(null, arguments));\n\t}\n\tfunction _extend(origin, add) {\n\t  // Don't do anything if add isn't an object\n\t  if (!add || !isObject(add)) return origin;\n\t  var keys = Object.keys(add);\n\t  var i = keys.length;\n\n\t  while (i--) {\n\t    origin[keys[i]] = add[keys[i]];\n\t  }\n\n\t  return origin;\n\t}\n\n\tfunction hasOwnProperty(obj, prop) {\n\t  return Object.prototype.hasOwnProperty.call(obj, prop);\n\t}\n\n\tvar util = {\n\t  inherits: inherits$1,\n\t  _extend: _extend,\n\t  log: log,\n\t  isBuffer: isBuffer,\n\t  isPrimitive: isPrimitive,\n\t  isFunction: isFunction,\n\t  isError: isError,\n\t  isDate: isDate,\n\t  isObject: isObject,\n\t  isRegExp: isRegExp,\n\t  isUndefined: isUndefined,\n\t  isSymbol: isSymbol,\n\t  isString: isString,\n\t  isNumber: isNumber,\n\t  isNullOrUndefined: isNullOrUndefined,\n\t  isNull: isNull,\n\t  isBoolean: isBoolean,\n\t  isArray: isArray,\n\t  inspect: inspect,\n\t  deprecate: deprecate,\n\t  format: format,\n\t  debuglog: debuglog\n\t};\n\n\tvar util$1 = /*#__PURE__*/Object.freeze({\n\t\tformat: format,\n\t\tdeprecate: deprecate,\n\t\tdebuglog: debuglog,\n\t\tinspect: inspect,\n\t\tisArray: isArray,\n\t\tisBoolean: isBoolean,\n\t\tisNull: isNull,\n\t\tisNullOrUndefined: isNullOrUndefined,\n\t\tisNumber: isNumber,\n\t\tisString: isString,\n\t\tisSymbol: isSymbol,\n\t\tisUndefined: isUndefined,\n\t\tisRegExp: isRegExp,\n\t\tisObject: isObject,\n\t\tisDate: isDate,\n\t\tisError: isError,\n\t\tisFunction: isFunction,\n\t\tisPrimitive: isPrimitive,\n\t\tisBuffer: isBuffer,\n\t\tlog: log,\n\t\tinherits: inherits$1,\n\t\t_extend: _extend,\n\t\tdefault: util\n\t});\n\n\tvar util$2 = getCjsExportFromNamespace(util$1);\n\n\tfunction _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$2(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }\n\n\tvar Buffer$1 = buffer.Buffer;\n\tvar randomBytes$1 = utils.randomBytes;\n\tvar deprecate$1 = util$2.deprecate; // constants\n\n\tvar PROCESS_UNIQUE = randomBytes$1(5); // Regular expression that checks for hex value\n\n\tvar checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');\n\tvar hasBufferType = false; // Check if buffer exists\n\n\ttry {\n\t  if (Buffer$1 && Buffer$1.from) hasBufferType = true;\n\t} catch (err) {\n\t  hasBufferType = false;\n\t} // Precomputed hex table enables speedy hex string conversion\n\n\n\tvar hexTable = [];\n\n\tfor (var _i = 0; _i < 256; _i++) {\n\t  hexTable[_i] = (_i <= 15 ? '0' : '') + _i.toString(16);\n\t} // Lookup tables\n\n\n\tvar decodeLookup = [];\n\tvar i = 0;\n\n\twhile (i < 10) {\n\t  decodeLookup[0x30 + i] = i++;\n\t}\n\n\twhile (i < 16) {\n\t  decodeLookup[0x41 - 10 + i] = decodeLookup[0x61 - 10 + i] = i++;\n\t}\n\n\tvar _Buffer = Buffer$1;\n\n\tfunction convertToHex(bytes) {\n\t  return bytes.toString('hex');\n\t}\n\n\tfunction makeObjectIdError(invalidString, index) {\n\t  var invalidCharacter = invalidString[index];\n\t  return new TypeError(\"ObjectId string \\\"\".concat(invalidString, \"\\\" contains invalid character \\\"\").concat(invalidCharacter, \"\\\" with character code (\").concat(invalidString.charCodeAt(index), \"). All character codes for a non-hex string must be less than 256.\"));\n\t}\n\t/**\n\t * A class representation of the BSON ObjectId type.\n\t */\n\n\n\tvar ObjectId =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create an ObjectId type\n\t   *\n\t   * @param {(string|Buffer|number)} id Can be a 24 byte hex string, 12 byte binary Buffer, or a Number.\n\t   * @property {number} generationTime The generation time of this ObjectId instance\n\t   * @return {ObjectId} instance of ObjectId.\n\t   */\n\t  function ObjectId(id) {\n\t    _classCallCheck$2(this, ObjectId);\n\n\t    // Duck-typing to support ObjectId from different npm packages\n\t    if (id instanceof ObjectId) return id; // The most common usecase (blank id, new objectId instance)\n\n\t    if (id == null || typeof id === 'number') {\n\t      // Generate a new id\n\t      this.id = ObjectId.generate(id); // If we are caching the hex string\n\n\t      if (ObjectId.cacheHexString) this.__id = this.toString('hex'); // Return the object\n\n\t      return;\n\t    } // Check if the passed in id is valid\n\n\n\t    var valid = ObjectId.isValid(id); // Throw an error if it's not a valid setup\n\n\t    if (!valid && id != null) {\n\t      throw new TypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');\n\t    } else if (valid && typeof id === 'string' && id.length === 24 && hasBufferType) {\n\t      return new ObjectId(Buffer$1.from(id, 'hex'));\n\t    } else if (valid && typeof id === 'string' && id.length === 24) {\n\t      return ObjectId.createFromHexString(id);\n\t    } else if (id != null && id.length === 12) {\n\t      // assume 12 byte string\n\t      this.id = id;\n\t    } else if (id != null && id.toHexString) {\n\t      // Duck-typing to support ObjectId from different npm packages\n\t      return ObjectId.createFromHexString(id.toHexString());\n\t    } else {\n\t      throw new TypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');\n\t    }\n\n\t    if (ObjectId.cacheHexString) this.__id = this.toString('hex');\n\t  }\n\t  /**\n\t   * Return the ObjectId id as a 24 byte hex string representation\n\t   *\n\t   * @method\n\t   * @return {string} return the 24 byte hex string representation.\n\t   */\n\n\n\t  _createClass$2(ObjectId, [{\n\t    key: \"toHexString\",\n\t    value: function toHexString() {\n\t      if (ObjectId.cacheHexString && this.__id) return this.__id;\n\t      var hexString = '';\n\n\t      if (!this.id || !this.id.length) {\n\t        throw new TypeError('invalid ObjectId, ObjectId.id must be either a string or a Buffer, but is [' + JSON.stringify(this.id) + ']');\n\t      }\n\n\t      if (this.id instanceof _Buffer) {\n\t        hexString = convertToHex(this.id);\n\t        if (ObjectId.cacheHexString) this.__id = hexString;\n\t        return hexString;\n\t      }\n\n\t      for (var _i2 = 0; _i2 < this.id.length; _i2++) {\n\t        var hexChar = hexTable[this.id.charCodeAt(_i2)];\n\n\t        if (typeof hexChar !== 'string') {\n\t          throw makeObjectIdError(this.id, _i2);\n\t        }\n\n\t        hexString += hexChar;\n\t      }\n\n\t      if (ObjectId.cacheHexString) this.__id = hexString;\n\t      return hexString;\n\t    }\n\t    /**\n\t     * Update the ObjectId index used in generating new ObjectId's on the driver\n\t     *\n\t     * @method\n\t     * @return {number} returns next index value.\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toString\",\n\n\t    /**\n\t     * Converts the id into a 24 byte hex string for printing\n\t     *\n\t     * @param {String} format The Buffer toString format parameter.\n\t     * @return {String} return the 24 byte hex string representation.\n\t     * @ignore\n\t     */\n\t    value: function toString(format) {\n\t      // Is the id a buffer then use the buffer toString method to return the format\n\t      if (this.id && this.id.copy) {\n\t        return this.id.toString(typeof format === 'string' ? format : 'hex');\n\t      }\n\n\t      return this.toHexString();\n\t    }\n\t    /**\n\t     * Converts to its JSON representation.\n\t     *\n\t     * @return {String} return the 24 byte hex string representation.\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.toHexString();\n\t    }\n\t    /**\n\t     * Compares the equality of this ObjectId with `otherID`.\n\t     *\n\t     * @method\n\t     * @param {object} otherId ObjectId instance to compare against.\n\t     * @return {boolean} the result of comparing two ObjectId's\n\t     */\n\n\t  }, {\n\t    key: \"equals\",\n\t    value: function equals(otherId) {\n\t      if (otherId instanceof ObjectId) {\n\t        return this.toString() === otherId.toString();\n\t      }\n\n\t      if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12 && this.id instanceof _Buffer) {\n\t        return otherId === this.id.toString('binary');\n\t      }\n\n\t      if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 24) {\n\t        return otherId.toLowerCase() === this.toHexString();\n\t      }\n\n\t      if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12) {\n\t        return otherId === this.id;\n\t      }\n\n\t      if (otherId != null && (otherId instanceof ObjectId || otherId.toHexString)) {\n\t        return otherId.toHexString() === this.toHexString();\n\t      }\n\n\t      return false;\n\t    }\n\t    /**\n\t     * Returns the generation date (accurate up to the second) that this ID was generated.\n\t     *\n\t     * @method\n\t     * @return {Date} the generation date\n\t     */\n\n\t  }, {\n\t    key: \"getTimestamp\",\n\t    value: function getTimestamp() {\n\t      var timestamp = new Date();\n\t      var time = this.id.readUInt32BE(0);\n\t      timestamp.setTime(Math.floor(time) * 1000);\n\t      return timestamp;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\n\t    /**\n\t     * @ignore\n\t     */\n\t    value: function toExtendedJSON() {\n\t      if (this.toHexString) return {\n\t        $oid: this.toHexString()\n\t      };\n\t      return {\n\t        $oid: this.toString('hex')\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"getInc\",\n\t    value: function getInc() {\n\t      return ObjectId.index = (ObjectId.index + 1) % 0xffffff;\n\t    }\n\t    /**\n\t     * Generate a 12 byte id buffer used in ObjectId's\n\t     *\n\t     * @method\n\t     * @param {number} [time] optional parameter allowing to pass in a second based timestamp.\n\t     * @return {Buffer} return the 12 byte id buffer string.\n\t     */\n\n\t  }, {\n\t    key: \"generate\",\n\t    value: function generate(time) {\n\t      if ('number' !== typeof time) {\n\t        time = ~~(Date.now() / 1000);\n\t      }\n\n\t      var inc = ObjectId.getInc();\n\t      var buffer$$1 = Buffer$1.alloc(12); // 4-byte timestamp\n\n\t      buffer$$1[3] = time & 0xff;\n\t      buffer$$1[2] = time >> 8 & 0xff;\n\t      buffer$$1[1] = time >> 16 & 0xff;\n\t      buffer$$1[0] = time >> 24 & 0xff; // 5-byte process unique\n\n\t      buffer$$1[4] = PROCESS_UNIQUE[0];\n\t      buffer$$1[5] = PROCESS_UNIQUE[1];\n\t      buffer$$1[6] = PROCESS_UNIQUE[2];\n\t      buffer$$1[7] = PROCESS_UNIQUE[3];\n\t      buffer$$1[8] = PROCESS_UNIQUE[4]; // 3-byte counter\n\n\t      buffer$$1[11] = inc & 0xff;\n\t      buffer$$1[10] = inc >> 8 & 0xff;\n\t      buffer$$1[9] = inc >> 16 & 0xff;\n\t      return buffer$$1;\n\t    }\n\t  }, {\n\t    key: \"createPk\",\n\t    value: function createPk() {\n\t      return new ObjectId();\n\t    }\n\t    /**\n\t     * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.\n\t     *\n\t     * @method\n\t     * @param {number} time an integer number representing a number of seconds.\n\t     * @return {ObjectId} return the created ObjectId\n\t     */\n\n\t  }, {\n\t    key: \"createFromTime\",\n\t    value: function createFromTime(time) {\n\t      var buffer$$1 = Buffer$1.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // Encode time into first 4 bytes\n\n\t      buffer$$1[3] = time & 0xff;\n\t      buffer$$1[2] = time >> 8 & 0xff;\n\t      buffer$$1[1] = time >> 16 & 0xff;\n\t      buffer$$1[0] = time >> 24 & 0xff; // Return the new objectId\n\n\t      return new ObjectId(buffer$$1);\n\t    }\n\t    /**\n\t     * Creates an ObjectId from a hex string representation of an ObjectId.\n\t     *\n\t     * @method\n\t     * @param {string} hexString create a ObjectId from a passed in 24 byte hexstring.\n\t     * @return {ObjectId} return the created ObjectId\n\t     */\n\n\t  }, {\n\t    key: \"createFromHexString\",\n\t    value: function createFromHexString(string) {\n\t      // Throw an error if it's not a valid setup\n\t      if (typeof string === 'undefined' || string != null && string.length !== 24) {\n\t        throw new TypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');\n\t      } // Use Buffer.from method if available\n\n\n\t      if (hasBufferType) return new ObjectId(Buffer$1.from(string, 'hex')); // Calculate lengths\n\n\t      var array = new _Buffer(12);\n\t      var n = 0;\n\t      var i = 0;\n\n\t      while (i < 24) {\n\t        array[n++] = decodeLookup[string.charCodeAt(i++)] << 4 | decodeLookup[string.charCodeAt(i++)];\n\t      }\n\n\t      return new ObjectId(array);\n\t    }\n\t    /**\n\t     * Checks if a value is a valid bson ObjectId\n\t     *\n\t     * @method\n\t     * @return {boolean} return true if the value is a valid bson ObjectId, return false otherwise.\n\t     */\n\n\t  }, {\n\t    key: \"isValid\",\n\t    value: function isValid(id) {\n\t      if (id == null) return false;\n\n\t      if (typeof id === 'number') {\n\t        return true;\n\t      }\n\n\t      if (typeof id === 'string') {\n\t        return id.length === 12 || id.length === 24 && checkForHexRegExp.test(id);\n\t      }\n\n\t      if (id instanceof ObjectId) {\n\t        return true;\n\t      }\n\n\t      if (id instanceof _Buffer && id.length === 12) {\n\t        return true;\n\t      } // Duck-Typing detection of ObjectId like objects\n\n\n\t      if (id.toHexString) {\n\t        return id.id.length === 12 || id.id.length === 24 && checkForHexRegExp.test(id.id);\n\t      }\n\n\t      return false;\n\t    }\n\t  }, {\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new ObjectId(doc.$oid);\n\t    }\n\t  }]);\n\n\t  return ObjectId;\n\t}(); // Deprecated methods\n\n\n\tObjectId.get_inc = deprecate$1(function () {\n\t  return ObjectId.getInc();\n\t}, 'Please use the static `ObjectId.getInc()` instead');\n\tObjectId.prototype.get_inc = deprecate$1(function () {\n\t  return ObjectId.getInc();\n\t}, 'Please use the static `ObjectId.getInc()` instead');\n\tObjectId.prototype.getInc = deprecate$1(function () {\n\t  return ObjectId.getInc();\n\t}, 'Please use the static `ObjectId.getInc()` instead');\n\tObjectId.prototype.generate = deprecate$1(function (time) {\n\t  return ObjectId.generate(time);\n\t}, 'Please use the static `ObjectId.generate(time)` instead');\n\t/**\n\t * @ignore\n\t */\n\n\tObject.defineProperty(ObjectId.prototype, 'generationTime', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return this.id[3] | this.id[2] << 8 | this.id[1] << 16 | this.id[0] << 24;\n\t  },\n\t  set: function set(value) {\n\t    // Encode time into first 4 bytes\n\t    this.id[3] = value & 0xff;\n\t    this.id[2] = value >> 8 & 0xff;\n\t    this.id[1] = value >> 16 & 0xff;\n\t    this.id[0] = value >> 24 & 0xff;\n\t  }\n\t});\n\t/**\n\t * Converts to a string representation of this Id.\n\t *\n\t * @return {String} return the 24 byte hex string representation.\n\t * @ignore\n\t */\n\n\tObjectId.prototype[util$2.inspect.custom || 'inspect'] = ObjectId.prototype.toString;\n\t/**\n\t * @ignore\n\t */\n\n\tObjectId.index = ~~(Math.random() * 0xffffff); // In 4.0.0 and 4.0.1, this property name was changed to ObjectId to match the class name.\n\t// This caused interoperability problems with previous versions of the library, so in\n\t// later builds we changed it back to ObjectID (capital D) to match legacy implementations.\n\n\tObject.defineProperty(ObjectId.prototype, '_bsontype', {\n\t  value: 'ObjectID'\n\t});\n\tvar objectid = ObjectId;\n\n\tfunction _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$3(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$3(Constructor.prototype, protoProps); if (staticProps) _defineProperties$3(Constructor, staticProps); return Constructor; }\n\n\tfunction alphabetize(str) {\n\t  return str.split('').sort().join('');\n\t}\n\t/**\n\t * A class representation of the BSON RegExp type.\n\t */\n\n\n\tvar BSONRegExp =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a RegExp type\n\t   *\n\t   * @param {string} pattern The regular expression pattern to match\n\t   * @param {string} options The regular expression options\n\t   */\n\t  function BSONRegExp(pattern, options) {\n\t    _classCallCheck$3(this, BSONRegExp);\n\n\t    // Execute\n\t    this.pattern = pattern || '';\n\t    this.options = options ? alphabetize(options) : ''; // Validate options\n\n\t    for (var i = 0; i < this.options.length; i++) {\n\t      if (!(this.options[i] === 'i' || this.options[i] === 'm' || this.options[i] === 'x' || this.options[i] === 'l' || this.options[i] === 's' || this.options[i] === 'u')) {\n\t        throw new Error(\"The regular expression option [\".concat(this.options[i], \"] is not supported\"));\n\t      }\n\t    }\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$3(BSONRegExp, [{\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $regularExpression: {\n\t          pattern: this.pattern,\n\t          options: this.options\n\t        }\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new BSONRegExp(doc.$regularExpression.pattern, doc.$regularExpression.options.split('').sort().join(''));\n\t    }\n\t  }]);\n\n\t  return BSONRegExp;\n\t}();\n\n\tObject.defineProperty(BSONRegExp.prototype, '_bsontype', {\n\t  value: 'BSONRegExp'\n\t});\n\tvar regexp = BSONRegExp;\n\n\t/**\n\t * A class representation of the BSON Symbol type.\n\t */\n\n\tfunction _classCallCheck$4(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$4(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$4(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$4(Constructor.prototype, protoProps); if (staticProps) _defineProperties$4(Constructor, staticProps); return Constructor; }\n\n\tvar BSONSymbol =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Symbol type\n\t   *\n\t   * @param {string} value the string representing the symbol.\n\t   */\n\t  function BSONSymbol(value) {\n\t    _classCallCheck$4(this, BSONSymbol);\n\n\t    this.value = value;\n\t  }\n\t  /**\n\t   * Access the wrapped string value.\n\t   *\n\t   * @method\n\t   * @return {String} returns the wrapped string.\n\t   */\n\n\n\t  _createClass$4(BSONSymbol, [{\n\t    key: \"valueOf\",\n\t    value: function valueOf() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toString\",\n\t    value: function toString() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"inspect\",\n\t    value: function inspect() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $symbol: this.value\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new BSONSymbol(doc.$symbol);\n\t    }\n\t  }]);\n\n\t  return BSONSymbol;\n\t}();\n\n\tObject.defineProperty(BSONSymbol.prototype, '_bsontype', {\n\t  value: 'Symbol'\n\t});\n\tvar symbol = BSONSymbol;\n\n\t/**\n\t * A class representation of a BSON Int32 type.\n\t */\n\n\tfunction _classCallCheck$5(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$5(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$5(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$5(Constructor.prototype, protoProps); if (staticProps) _defineProperties$5(Constructor, staticProps); return Constructor; }\n\n\tvar Int32 =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create an Int32 type\n\t   *\n\t   * @param {number} value the number we want to represent as an int32.\n\t   * @return {Int32}\n\t   */\n\t  function Int32(value) {\n\t    _classCallCheck$5(this, Int32);\n\n\t    this.value = value;\n\t  }\n\t  /**\n\t   * Access the number value.\n\t   *\n\t   * @method\n\t   * @return {number} returns the wrapped int32 number.\n\t   */\n\n\n\t  _createClass$5(Int32, [{\n\t    key: \"valueOf\",\n\t    value: function valueOf() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON(options) {\n\t      if (options && options.relaxed) return this.value;\n\t      return {\n\t        $numberInt: this.value.toString()\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc, options) {\n\t      return options && options.relaxed ? parseInt(doc.$numberInt, 10) : new Int32(doc.$numberInt);\n\t    }\n\t  }]);\n\n\t  return Int32;\n\t}();\n\n\tObject.defineProperty(Int32.prototype, '_bsontype', {\n\t  value: 'Int32'\n\t});\n\tvar int_32 = Int32;\n\n\t/**\n\t * A class representation of the BSON Code type.\n\t */\n\n\tfunction _classCallCheck$6(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$6(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$6(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$6(Constructor.prototype, protoProps); if (staticProps) _defineProperties$6(Constructor, staticProps); return Constructor; }\n\n\tvar Code =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Code type\n\t   *\n\t   * @param {(string|function)} code a string or function.\n\t   * @param {Object} [scope] an optional scope for the function.\n\t   * @return {Code}\n\t   */\n\t  function Code(code, scope) {\n\t    _classCallCheck$6(this, Code);\n\n\t    this.code = code;\n\t    this.scope = scope;\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$6(Code, [{\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return {\n\t        scope: this.scope,\n\t        code: this.code\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      if (this.scope) {\n\t        return {\n\t          $code: this.code,\n\t          $scope: this.scope\n\t        };\n\t      }\n\n\t      return {\n\t        $code: this.code\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new Code(doc.$code, doc.$scope);\n\t    }\n\t  }]);\n\n\t  return Code;\n\t}();\n\n\tObject.defineProperty(Code.prototype, '_bsontype', {\n\t  value: 'Code'\n\t});\n\tvar code = Code;\n\n\tvar Buffer$2 = buffer.Buffer;\n\tvar PARSE_STRING_REGEXP = /^(\\+|-)?(\\d+|(\\d*\\.\\d*))?(E|e)?([-+])?(\\d+)?$/;\n\tvar PARSE_INF_REGEXP = /^(\\+|-)?(Infinity|inf)$/i;\n\tvar PARSE_NAN_REGEXP = /^(\\+|-)?NaN$/i;\n\tvar EXPONENT_MAX = 6111;\n\tvar EXPONENT_MIN = -6176;\n\tvar EXPONENT_BIAS = 6176;\n\tvar MAX_DIGITS = 34; // Nan value bits as 32 bit values (due to lack of longs)\n\n\tvar NAN_BUFFER = [0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].reverse(); // Infinity value bits 32 bit values (due to lack of longs)\n\n\tvar INF_NEGATIVE_BUFFER = [0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].reverse();\n\tvar INF_POSITIVE_BUFFER = [0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].reverse();\n\tvar EXPONENT_REGEX = /^([-+])?(\\d+)?$/; // Detect if the value is a digit\n\n\tfunction isDigit(value) {\n\t  return !isNaN(parseInt(value, 10));\n\t} // Divide two uint128 values\n\n\n\tfunction divideu128(value) {\n\t  var DIVISOR = long_1.fromNumber(1000 * 1000 * 1000);\n\n\t  var _rem = long_1.fromNumber(0);\n\n\t  if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) {\n\t    return {\n\t      quotient: value,\n\t      rem: _rem\n\t    };\n\t  }\n\n\t  for (var i = 0; i <= 3; i++) {\n\t    // Adjust remainder to match value of next dividend\n\t    _rem = _rem.shiftLeft(32); // Add the divided to _rem\n\n\t    _rem = _rem.add(new long_1(value.parts[i], 0));\n\t    value.parts[i] = _rem.div(DIVISOR).low;\n\t    _rem = _rem.modulo(DIVISOR);\n\t  }\n\n\t  return {\n\t    quotient: value,\n\t    rem: _rem\n\t  };\n\t} // Multiply two Long values and return the 128 bit value\n\n\n\tfunction multiply64x2(left, right) {\n\t  if (!left && !right) {\n\t    return {\n\t      high: long_1.fromNumber(0),\n\t      low: long_1.fromNumber(0)\n\t    };\n\t  }\n\n\t  var leftHigh = left.shiftRightUnsigned(32);\n\t  var leftLow = new long_1(left.getLowBits(), 0);\n\t  var rightHigh = right.shiftRightUnsigned(32);\n\t  var rightLow = new long_1(right.getLowBits(), 0);\n\t  var productHigh = leftHigh.multiply(rightHigh);\n\t  var productMid = leftHigh.multiply(rightLow);\n\t  var productMid2 = leftLow.multiply(rightHigh);\n\t  var productLow = leftLow.multiply(rightLow);\n\t  productHigh = productHigh.add(productMid.shiftRightUnsigned(32));\n\t  productMid = new long_1(productMid.getLowBits(), 0).add(productMid2).add(productLow.shiftRightUnsigned(32));\n\t  productHigh = productHigh.add(productMid.shiftRightUnsigned(32));\n\t  productLow = productMid.shiftLeft(32).add(new long_1(productLow.getLowBits(), 0)); // Return the 128 bit result\n\n\t  return {\n\t    high: productHigh,\n\t    low: productLow\n\t  };\n\t}\n\n\tfunction lessThan(left, right) {\n\t  // Make values unsigned\n\t  var uhleft = left.high >>> 0;\n\t  var uhright = right.high >>> 0; // Compare high bits first\n\n\t  if (uhleft < uhright) {\n\t    return true;\n\t  } else if (uhleft === uhright) {\n\t    var ulleft = left.low >>> 0;\n\t    var ulright = right.low >>> 0;\n\t    if (ulleft < ulright) return true;\n\t  }\n\n\t  return false;\n\t}\n\n\tfunction invalidErr(string, message) {\n\t  throw new TypeError(\"\\\"\".concat(string, \"\\\" is not a valid Decimal128 string - \").concat(message));\n\t}\n\t/**\n\t * A class representation of the BSON Decimal128 type.\n\t *\n\t * @class\n\t * @param {Buffer} bytes a buffer containing the raw Decimal128 bytes.\n\t * @return {Double}\n\t */\n\n\n\tfunction Decimal128(bytes) {\n\t  this.bytes = bytes;\n\t}\n\t/**\n\t * Create a Decimal128 instance from a string representation\n\t *\n\t * @method\n\t * @param {string} string a numeric string representation.\n\t * @return {Decimal128} returns a Decimal128 instance.\n\t */\n\n\n\tDecimal128.fromString = function (string) {\n\t  // Parse state tracking\n\t  var isNegative = false;\n\t  var sawRadix = false;\n\t  var foundNonZero = false; // Total number of significant digits (no leading or trailing zero)\n\n\t  var significantDigits = 0; // Total number of significand digits read\n\n\t  var nDigitsRead = 0; // Total number of digits (no leading zeros)\n\n\t  var nDigits = 0; // The number of the digits after radix\n\n\t  var radixPosition = 0; // The index of the first non-zero in *str*\n\n\t  var firstNonZero = 0; // Digits Array\n\n\t  var digits = [0]; // The number of digits in digits\n\n\t  var nDigitsStored = 0; // Insertion pointer for digits\n\n\t  var digitsInsert = 0; // The index of the first non-zero digit\n\n\t  var firstDigit = 0; // The index of the last digit\n\n\t  var lastDigit = 0; // Exponent\n\n\t  var exponent = 0; // loop index over array\n\n\t  var i = 0; // The high 17 digits of the significand\n\n\t  var significandHigh = [0, 0]; // The low 17 digits of the significand\n\n\t  var significandLow = [0, 0]; // The biased exponent\n\n\t  var biasedExponent = 0; // Read index\n\n\t  var index = 0; // Naively prevent against REDOS attacks.\n\t  // TODO: implementing a custom parsing for this, or refactoring the regex would yield\n\t  //       further gains.\n\n\t  if (string.length >= 7000) {\n\t    throw new TypeError('' + string + ' not a valid Decimal128 string');\n\t  } // Results\n\n\n\t  var stringMatch = string.match(PARSE_STRING_REGEXP);\n\t  var infMatch = string.match(PARSE_INF_REGEXP);\n\t  var nanMatch = string.match(PARSE_NAN_REGEXP); // Validate the string\n\n\t  if (!stringMatch && !infMatch && !nanMatch || string.length === 0) {\n\t    throw new TypeError('' + string + ' not a valid Decimal128 string');\n\t  }\n\n\t  if (stringMatch) {\n\t    // full_match = stringMatch[0]\n\t    // sign = stringMatch[1]\n\t    var unsignedNumber = stringMatch[2]; // stringMatch[3] is undefined if a whole number (ex \"1\", 12\")\n\t    // but defined if a number w/ decimal in it (ex \"1.0, 12.2\")\n\n\t    var e = stringMatch[4];\n\t    var expSign = stringMatch[5];\n\t    var expNumber = stringMatch[6]; // they provided e, but didn't give an exponent number. for ex \"1e\"\n\n\t    if (e && expNumber === undefined) invalidErr(string, 'missing exponent power'); // they provided e, but didn't give a number before it. for ex \"e1\"\n\n\t    if (e && unsignedNumber === undefined) invalidErr(string, 'missing exponent base');\n\n\t    if (e === undefined && (expSign || expNumber)) {\n\t      invalidErr(string, 'missing e before exponent');\n\t    }\n\t  } // Get the negative or positive sign\n\n\n\t  if (string[index] === '+' || string[index] === '-') {\n\t    isNegative = string[index++] === '-';\n\t  } // Check if user passed Infinity or NaN\n\n\n\t  if (!isDigit(string[index]) && string[index] !== '.') {\n\t    if (string[index] === 'i' || string[index] === 'I') {\n\t      return new Decimal128(Buffer$2.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));\n\t    } else if (string[index] === 'N') {\n\t      return new Decimal128(Buffer$2.from(NAN_BUFFER));\n\t    }\n\t  } // Read all the digits\n\n\n\t  while (isDigit(string[index]) || string[index] === '.') {\n\t    if (string[index] === '.') {\n\t      if (sawRadix) invalidErr(string, 'contains multiple periods');\n\t      sawRadix = true;\n\t      index = index + 1;\n\t      continue;\n\t    }\n\n\t    if (nDigitsStored < 34) {\n\t      if (string[index] !== '0' || foundNonZero) {\n\t        if (!foundNonZero) {\n\t          firstNonZero = nDigitsRead;\n\t        }\n\n\t        foundNonZero = true; // Only store 34 digits\n\n\t        digits[digitsInsert++] = parseInt(string[index], 10);\n\t        nDigitsStored = nDigitsStored + 1;\n\t      }\n\t    }\n\n\t    if (foundNonZero) nDigits = nDigits + 1;\n\t    if (sawRadix) radixPosition = radixPosition + 1;\n\t    nDigitsRead = nDigitsRead + 1;\n\t    index = index + 1;\n\t  }\n\n\t  if (sawRadix && !nDigitsRead) throw new TypeError('' + string + ' not a valid Decimal128 string'); // Read exponent if exists\n\n\t  if (string[index] === 'e' || string[index] === 'E') {\n\t    // Read exponent digits\n\t    var match = string.substr(++index).match(EXPONENT_REGEX); // No digits read\n\n\t    if (!match || !match[2]) return new Decimal128(Buffer$2.from(NAN_BUFFER)); // Get exponent\n\n\t    exponent = parseInt(match[0], 10); // Adjust the index\n\n\t    index = index + match[0].length;\n\t  } // Return not a number\n\n\n\t  if (string[index]) return new Decimal128(Buffer$2.from(NAN_BUFFER)); // Done reading input\n\t  // Find first non-zero digit in digits\n\n\t  firstDigit = 0;\n\n\t  if (!nDigitsStored) {\n\t    firstDigit = 0;\n\t    lastDigit = 0;\n\t    digits[0] = 0;\n\t    nDigits = 1;\n\t    nDigitsStored = 1;\n\t    significantDigits = 0;\n\t  } else {\n\t    lastDigit = nDigitsStored - 1;\n\t    significantDigits = nDigits;\n\n\t    if (significantDigits !== 1) {\n\t      while (string[firstNonZero + significantDigits - 1] === '0') {\n\t        significantDigits = significantDigits - 1;\n\t      }\n\t    }\n\t  } // Normalization of exponent\n\t  // Correct exponent based on radix position, and shift significand as needed\n\t  // to represent user input\n\t  // Overflow prevention\n\n\n\t  if (exponent <= radixPosition && radixPosition - exponent > 1 << 14) {\n\t    exponent = EXPONENT_MIN;\n\t  } else {\n\t    exponent = exponent - radixPosition;\n\t  } // Attempt to normalize the exponent\n\n\n\t  while (exponent > EXPONENT_MAX) {\n\t    // Shift exponent to significand and decrease\n\t    lastDigit = lastDigit + 1;\n\n\t    if (lastDigit - firstDigit > MAX_DIGITS) {\n\t      // Check if we have a zero then just hard clamp, otherwise fail\n\t      var digitsString = digits.join('');\n\n\t      if (digitsString.match(/^0+$/)) {\n\t        exponent = EXPONENT_MAX;\n\t        break;\n\t      }\n\n\t      invalidErr(string, 'overflow');\n\t    }\n\n\t    exponent = exponent - 1;\n\t  }\n\n\t  while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {\n\t    // Shift last digit. can only do this if < significant digits than # stored.\n\t    if (lastDigit === 0 && significantDigits < nDigitsStored) {\n\t      exponent = EXPONENT_MIN;\n\t      significantDigits = 0;\n\t      break;\n\t    }\n\n\t    if (nDigitsStored < nDigits) {\n\t      // adjust to match digits not stored\n\t      nDigits = nDigits - 1;\n\t    } else {\n\t      // adjust to round\n\t      lastDigit = lastDigit - 1;\n\t    }\n\n\t    if (exponent < EXPONENT_MAX) {\n\t      exponent = exponent + 1;\n\t    } else {\n\t      // Check if we have a zero then just hard clamp, otherwise fail\n\t      var _digitsString = digits.join('');\n\n\t      if (_digitsString.match(/^0+$/)) {\n\t        exponent = EXPONENT_MAX;\n\t        break;\n\t      }\n\n\t      invalidErr(string, 'overflow');\n\t    }\n\t  } // Round\n\t  // We've normalized the exponent, but might still need to round.\n\n\n\t  if (lastDigit - firstDigit + 1 < significantDigits) {\n\t    var endOfString = nDigitsRead; // If we have seen a radix point, 'string' is 1 longer than we have\n\t    // documented with ndigits_read, so inc the position of the first nonzero\n\t    // digit and the position that digits are read to.\n\n\t    if (sawRadix) {\n\t      firstNonZero = firstNonZero + 1;\n\t      endOfString = endOfString + 1;\n\t    } // if negative, we need to increment again to account for - sign at start.\n\n\n\t    if (isNegative) {\n\t      firstNonZero = firstNonZero + 1;\n\t      endOfString = endOfString + 1;\n\t    }\n\n\t    var roundDigit = parseInt(string[firstNonZero + lastDigit + 1], 10);\n\t    var roundBit = 0;\n\n\t    if (roundDigit >= 5) {\n\t      roundBit = 1;\n\n\t      if (roundDigit === 5) {\n\t        roundBit = digits[lastDigit] % 2 === 1;\n\n\t        for (i = firstNonZero + lastDigit + 2; i < endOfString; i++) {\n\t          if (parseInt(string[i], 10)) {\n\t            roundBit = 1;\n\t            break;\n\t          }\n\t        }\n\t      }\n\t    }\n\n\t    if (roundBit) {\n\t      var dIdx = lastDigit;\n\n\t      for (; dIdx >= 0; dIdx--) {\n\t        if (++digits[dIdx] > 9) {\n\t          digits[dIdx] = 0; // overflowed most significant digit\n\n\t          if (dIdx === 0) {\n\t            if (exponent < EXPONENT_MAX) {\n\t              exponent = exponent + 1;\n\t              digits[dIdx] = 1;\n\t            } else {\n\t              return new Decimal128(Buffer$2.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));\n\t            }\n\t          }\n\t        }\n\t      }\n\t    }\n\t  } // Encode significand\n\t  // The high 17 digits of the significand\n\n\n\t  significandHigh = long_1.fromNumber(0); // The low 17 digits of the significand\n\n\t  significandLow = long_1.fromNumber(0); // read a zero\n\n\t  if (significantDigits === 0) {\n\t    significandHigh = long_1.fromNumber(0);\n\t    significandLow = long_1.fromNumber(0);\n\t  } else if (lastDigit - firstDigit < 17) {\n\t    var _dIdx = firstDigit;\n\t    significandLow = long_1.fromNumber(digits[_dIdx++]);\n\t    significandHigh = new long_1(0, 0);\n\n\t    for (; _dIdx <= lastDigit; _dIdx++) {\n\t      significandLow = significandLow.multiply(long_1.fromNumber(10));\n\t      significandLow = significandLow.add(long_1.fromNumber(digits[_dIdx]));\n\t    }\n\t  } else {\n\t    var _dIdx2 = firstDigit;\n\t    significandHigh = long_1.fromNumber(digits[_dIdx2++]);\n\n\t    for (; _dIdx2 <= lastDigit - 17; _dIdx2++) {\n\t      significandHigh = significandHigh.multiply(long_1.fromNumber(10));\n\t      significandHigh = significandHigh.add(long_1.fromNumber(digits[_dIdx2]));\n\t    }\n\n\t    significandLow = long_1.fromNumber(digits[_dIdx2++]);\n\n\t    for (; _dIdx2 <= lastDigit; _dIdx2++) {\n\t      significandLow = significandLow.multiply(long_1.fromNumber(10));\n\t      significandLow = significandLow.add(long_1.fromNumber(digits[_dIdx2]));\n\t    }\n\t  }\n\n\t  var significand = multiply64x2(significandHigh, long_1.fromString('100000000000000000'));\n\t  significand.low = significand.low.add(significandLow);\n\n\t  if (lessThan(significand.low, significandLow)) {\n\t    significand.high = significand.high.add(long_1.fromNumber(1));\n\t  } // Biased exponent\n\n\n\t  biasedExponent = exponent + EXPONENT_BIAS;\n\t  var dec = {\n\t    low: long_1.fromNumber(0),\n\t    high: long_1.fromNumber(0)\n\t  }; // Encode combination, exponent, and significand.\n\n\t  if (significand.high.shiftRightUnsigned(49).and(long_1.fromNumber(1)).equals(long_1.fromNumber(1))) {\n\t    // Encode '11' into bits 1 to 3\n\t    dec.high = dec.high.or(long_1.fromNumber(0x3).shiftLeft(61));\n\t    dec.high = dec.high.or(long_1.fromNumber(biasedExponent).and(long_1.fromNumber(0x3fff).shiftLeft(47)));\n\t    dec.high = dec.high.or(significand.high.and(long_1.fromNumber(0x7fffffffffff)));\n\t  } else {\n\t    dec.high = dec.high.or(long_1.fromNumber(biasedExponent & 0x3fff).shiftLeft(49));\n\t    dec.high = dec.high.or(significand.high.and(long_1.fromNumber(0x1ffffffffffff)));\n\t  }\n\n\t  dec.low = significand.low; // Encode sign\n\n\t  if (isNegative) {\n\t    dec.high = dec.high.or(long_1.fromString('9223372036854775808'));\n\t  } // Encode into a buffer\n\n\n\t  var buffer$$1 = Buffer$2.alloc(16);\n\t  index = 0; // Encode the low 64 bits of the decimal\n\t  // Encode low bits\n\n\t  buffer$$1[index++] = dec.low.low & 0xff;\n\t  buffer$$1[index++] = dec.low.low >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.low.low >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.low.low >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = dec.low.high & 0xff;\n\t  buffer$$1[index++] = dec.low.high >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.low.high >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.low.high >> 24 & 0xff; // Encode the high 64 bits of the decimal\n\t  // Encode low bits\n\n\t  buffer$$1[index++] = dec.high.low & 0xff;\n\t  buffer$$1[index++] = dec.high.low >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.high.low >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.high.low >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = dec.high.high & 0xff;\n\t  buffer$$1[index++] = dec.high.high >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.high.high >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.high.high >> 24 & 0xff; // Return the new Decimal128\n\n\t  return new Decimal128(buffer$$1);\n\t}; // Extract least significant 5 bits\n\n\n\tvar COMBINATION_MASK = 0x1f; // Extract least significant 14 bits\n\n\tvar EXPONENT_MASK = 0x3fff; // Value of combination field for Inf\n\n\tvar COMBINATION_INFINITY = 30; // Value of combination field for NaN\n\n\tvar COMBINATION_NAN = 31;\n\t/**\n\t * Create a string representation of the raw Decimal128 value\n\t *\n\t * @method\n\t * @return {string} returns a Decimal128 string representation.\n\t */\n\n\tDecimal128.prototype.toString = function () {\n\t  // Note: bits in this routine are referred to starting at 0,\n\t  // from the sign bit, towards the coefficient.\n\t  // bits 0 - 31\n\t  var high; // bits 32 - 63\n\n\t  var midh; // bits 64 - 95\n\n\t  var midl; // bits 96 - 127\n\n\t  var low; // bits 1 - 5\n\n\t  var combination; // decoded biased exponent (14 bits)\n\n\t  var biased_exponent; // the number of significand digits\n\n\t  var significand_digits = 0; // the base-10 digits in the significand\n\n\t  var significand = new Array(36);\n\n\t  for (var i = 0; i < significand.length; i++) {\n\t    significand[i] = 0;\n\t  } // read pointer into significand\n\n\n\t  var index = 0; // unbiased exponent\n\n\t  var exponent; // the exponent if scientific notation is used\n\n\t  var scientific_exponent; // true if the number is zero\n\n\t  var is_zero = false; // the most signifcant significand bits (50-46)\n\n\t  var significand_msb; // temporary storage for significand decoding\n\n\t  var significand128 = {\n\t    parts: new Array(4)\n\t  }; // indexing variables\n\n\t  var j, k; // Output string\n\n\t  var string = []; // Unpack index\n\n\t  index = 0; // Buffer reference\n\n\t  var buffer$$1 = this.bytes; // Unpack the low 64bits into a long\n\n\t  low = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t  midl = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Unpack the high 64bits into a long\n\n\t  midh = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t  high = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Unpack index\n\n\t  index = 0; // Create the state of the decimal\n\n\t  var dec = {\n\t    low: new long_1(low, midl),\n\t    high: new long_1(midh, high)\n\t  };\n\n\t  if (dec.high.lessThan(long_1.ZERO)) {\n\t    string.push('-');\n\t  } // Decode combination field and exponent\n\n\n\t  combination = high >> 26 & COMBINATION_MASK;\n\n\t  if (combination >> 3 === 3) {\n\t    // Check for 'special' values\n\t    if (combination === COMBINATION_INFINITY) {\n\t      return string.join('') + 'Infinity';\n\t    } else if (combination === COMBINATION_NAN) {\n\t      return 'NaN';\n\t    } else {\n\t      biased_exponent = high >> 15 & EXPONENT_MASK;\n\t      significand_msb = 0x08 + (high >> 14 & 0x01);\n\t    }\n\t  } else {\n\t    significand_msb = high >> 14 & 0x07;\n\t    biased_exponent = high >> 17 & EXPONENT_MASK;\n\t  }\n\n\t  exponent = biased_exponent - EXPONENT_BIAS; // Create string of significand digits\n\t  // Convert the 114-bit binary number represented by\n\t  // (significand_high, significand_low) to at most 34 decimal\n\t  // digits through modulo and division.\n\n\t  significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14);\n\t  significand128.parts[1] = midh;\n\t  significand128.parts[2] = midl;\n\t  significand128.parts[3] = low;\n\n\t  if (significand128.parts[0] === 0 && significand128.parts[1] === 0 && significand128.parts[2] === 0 && significand128.parts[3] === 0) {\n\t    is_zero = true;\n\t  } else {\n\t    for (k = 3; k >= 0; k--) {\n\t      var least_digits = 0; // Peform the divide\n\n\t      var result = divideu128(significand128);\n\t      significand128 = result.quotient;\n\t      least_digits = result.rem.low; // We now have the 9 least significant digits (in base 2).\n\t      // Convert and output to string.\n\n\t      if (!least_digits) continue;\n\n\t      for (j = 8; j >= 0; j--) {\n\t        // significand[k * 9 + j] = Math.round(least_digits % 10);\n\t        significand[k * 9 + j] = least_digits % 10; // least_digits = Math.round(least_digits / 10);\n\n\t        least_digits = Math.floor(least_digits / 10);\n\t      }\n\t    }\n\t  } // Output format options:\n\t  // Scientific - [-]d.dddE(+/-)dd or [-]dE(+/-)dd\n\t  // Regular    - ddd.ddd\n\n\n\t  if (is_zero) {\n\t    significand_digits = 1;\n\t    significand[index] = 0;\n\t  } else {\n\t    significand_digits = 36;\n\n\t    while (!significand[index]) {\n\t      significand_digits = significand_digits - 1;\n\t      index = index + 1;\n\t    }\n\t  }\n\n\t  scientific_exponent = significand_digits - 1 + exponent; // The scientific exponent checks are dictated by the string conversion\n\t  // specification and are somewhat arbitrary cutoffs.\n\t  //\n\t  // We must check exponent > 0, because if this is the case, the number\n\t  // has trailing zeros.  However, we *cannot* output these trailing zeros,\n\t  // because doing so would change the precision of the value, and would\n\t  // change stored data if the string converted number is round tripped.\n\n\t  if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) {\n\t    // Scientific format\n\t    // if there are too many significant digits, we should just be treating numbers\n\t    // as + or - 0 and using the non-scientific exponent (this is for the \"invalid\n\t    // representation should be treated as 0/-0\" spec cases in decimal128-1.json)\n\t    if (significand_digits > 34) {\n\t      string.push(0);\n\t      if (exponent > 0) string.push('E+' + exponent);else if (exponent < 0) string.push('E' + exponent);\n\t      return string.join('');\n\t    }\n\n\t    string.push(significand[index++]);\n\t    significand_digits = significand_digits - 1;\n\n\t    if (significand_digits) {\n\t      string.push('.');\n\t    }\n\n\t    for (var _i = 0; _i < significand_digits; _i++) {\n\t      string.push(significand[index++]);\n\t    } // Exponent\n\n\n\t    string.push('E');\n\n\t    if (scientific_exponent > 0) {\n\t      string.push('+' + scientific_exponent);\n\t    } else {\n\t      string.push(scientific_exponent);\n\t    }\n\t  } else {\n\t    // Regular format with no decimal place\n\t    if (exponent >= 0) {\n\t      for (var _i2 = 0; _i2 < significand_digits; _i2++) {\n\t        string.push(significand[index++]);\n\t      }\n\t    } else {\n\t      var radix_position = significand_digits + exponent; // non-zero digits before radix\n\n\t      if (radix_position > 0) {\n\t        for (var _i3 = 0; _i3 < radix_position; _i3++) {\n\t          string.push(significand[index++]);\n\t        }\n\t      } else {\n\t        string.push('0');\n\t      }\n\n\t      string.push('.'); // add leading zeros after radix\n\n\t      while (radix_position++ < 0) {\n\t        string.push('0');\n\t      }\n\n\t      for (var _i4 = 0; _i4 < significand_digits - Math.max(radix_position - 1, 0); _i4++) {\n\t        string.push(significand[index++]);\n\t      }\n\t    }\n\t  }\n\n\t  return string.join('');\n\t};\n\n\tDecimal128.prototype.toJSON = function () {\n\t  return {\n\t    $numberDecimal: this.toString()\n\t  };\n\t};\n\t/**\n\t * @ignore\n\t */\n\n\n\tDecimal128.prototype.toExtendedJSON = function () {\n\t  return {\n\t    $numberDecimal: this.toString()\n\t  };\n\t};\n\t/**\n\t * @ignore\n\t */\n\n\n\tDecimal128.fromExtendedJSON = function (doc) {\n\t  return Decimal128.fromString(doc.$numberDecimal);\n\t};\n\n\tObject.defineProperty(Decimal128.prototype, '_bsontype', {\n\t  value: 'Decimal128'\n\t});\n\tvar decimal128 = Decimal128;\n\n\t/**\n\t * A class representation of the BSON MinKey type.\n\t */\n\n\tfunction _classCallCheck$7(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$7(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$7(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$7(Constructor.prototype, protoProps); if (staticProps) _defineProperties$7(Constructor, staticProps); return Constructor; }\n\n\tvar MinKey =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a MinKey type\n\t   *\n\t   * @return {MinKey} A MinKey instance\n\t   */\n\t  function MinKey() {\n\t    _classCallCheck$7(this, MinKey);\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$7(MinKey, [{\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $minKey: 1\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON() {\n\t      return new MinKey();\n\t    }\n\t  }]);\n\n\t  return MinKey;\n\t}();\n\n\tObject.defineProperty(MinKey.prototype, '_bsontype', {\n\t  value: 'MinKey'\n\t});\n\tvar min_key = MinKey;\n\n\t/**\n\t * A class representation of the BSON MaxKey type.\n\t */\n\n\tfunction _classCallCheck$8(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$8(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$8(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$8(Constructor.prototype, protoProps); if (staticProps) _defineProperties$8(Constructor, staticProps); return Constructor; }\n\n\tvar MaxKey =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a MaxKey type\n\t   *\n\t   * @return {MaxKey} A MaxKey instance\n\t   */\n\t  function MaxKey() {\n\t    _classCallCheck$8(this, MaxKey);\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$8(MaxKey, [{\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $maxKey: 1\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON() {\n\t      return new MaxKey();\n\t    }\n\t  }]);\n\n\t  return MaxKey;\n\t}();\n\n\tObject.defineProperty(MaxKey.prototype, '_bsontype', {\n\t  value: 'MaxKey'\n\t});\n\tvar max_key = MaxKey;\n\n\t/**\n\t * A class representation of the BSON DBRef type.\n\t */\n\n\tfunction _classCallCheck$9(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$9(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$9(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$9(Constructor.prototype, protoProps); if (staticProps) _defineProperties$9(Constructor, staticProps); return Constructor; }\n\n\tvar DBRef =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a DBRef type\n\t   *\n\t   * @param {string} collection the collection name.\n\t   * @param {ObjectId} oid the reference ObjectId.\n\t   * @param {string} [db] optional db name, if omitted the reference is local to the current db.\n\t   * @return {DBRef}\n\t   */\n\t  function DBRef(collection, oid, db, fields) {\n\t    _classCallCheck$9(this, DBRef);\n\n\t    // check if namespace has been provided\n\t    var parts = collection.split('.');\n\n\t    if (parts.length === 2) {\n\t      db = parts.shift();\n\t      collection = parts.shift();\n\t    }\n\n\t    this.collection = collection;\n\t    this.oid = oid;\n\t    this.db = db;\n\t    this.fields = fields || {};\n\t  }\n\t  /**\n\t   * @ignore\n\t   * @api private\n\t   */\n\n\n\t  _createClass$9(DBRef, [{\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      var o = Object.assign({\n\t        $ref: this.collection,\n\t        $id: this.oid\n\t      }, this.fields);\n\t      if (this.db != null) o.$db = this.db;\n\t      return o;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      var o = {\n\t        $ref: this.collection,\n\t        $id: this.oid\n\t      };\n\t      if (this.db) o.$db = this.db;\n\t      o = Object.assign(o, this.fields);\n\t      return o;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      var copy = Object.assign({}, doc);\n\t      ['$ref', '$id', '$db'].forEach(function (k) {\n\t        return delete copy[k];\n\t      });\n\t      return new DBRef(doc.$ref, doc.$id, doc.$db, copy);\n\t    }\n\t  }]);\n\n\t  return DBRef;\n\t}();\n\n\tObject.defineProperty(DBRef.prototype, '_bsontype', {\n\t  value: 'DBRef'\n\t}); // the 1.x parser used a \"namespace\" property, while 4.x uses \"collection\". To ensure backwards\n\t// compatibility, let's expose \"namespace\"\n\n\tObject.defineProperty(DBRef.prototype, 'namespace', {\n\t  get: function get() {\n\t    return this.collection;\n\t  },\n\t  set: function set(val) {\n\t    this.collection = val;\n\t  },\n\t  configurable: false\n\t});\n\tvar db_ref = DBRef;\n\n\tfunction _classCallCheck$a(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$a(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$a(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$a(Constructor.prototype, protoProps); if (staticProps) _defineProperties$a(Constructor, staticProps); return Constructor; }\n\n\tvar Buffer$3 = buffer.Buffer;\n\t/**\n\t * A class representation of the BSON Binary type.\n\t */\n\n\tvar Binary =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Binary type\n\t   *\n\t   * Sub types\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_DEFAULT**, default BSON type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_FUNCTION**, BSON function type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY**, BSON byte array type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_UUID**, BSON uuid type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_MD5**, BSON md5 type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_USER_DEFINED**, BSON user defined type.\n\t   *\n\t   * @param {Buffer} buffer a buffer object containing the binary data.\n\t   * @param {Number} [subType] the option binary type.\n\t   * @return {Binary}\n\t   */\n\t  function Binary(buffer$$1, subType) {\n\t    _classCallCheck$a(this, Binary);\n\n\t    if (buffer$$1 != null && !(typeof buffer$$1 === 'string') && !Buffer$3.isBuffer(buffer$$1) && !(buffer$$1 instanceof Uint8Array) && !Array.isArray(buffer$$1)) {\n\t      throw new TypeError('only String, Buffer, Uint8Array or Array accepted');\n\t    }\n\n\t    this.sub_type = subType == null ? BSON_BINARY_SUBTYPE_DEFAULT : subType;\n\t    this.position = 0;\n\n\t    if (buffer$$1 != null && !(buffer$$1 instanceof Number)) {\n\t      // Only accept Buffer, Uint8Array or Arrays\n\t      if (typeof buffer$$1 === 'string') {\n\t        // Different ways of writing the length of the string for the different types\n\t        if (typeof Buffer$3 !== 'undefined') {\n\t          this.buffer = Buffer$3.from(buffer$$1);\n\t        } else if (typeof Uint8Array !== 'undefined' || Array.isArray(buffer$$1)) {\n\t          this.buffer = writeStringToArray(buffer$$1);\n\t        } else {\n\t          throw new TypeError('only String, Buffer, Uint8Array or Array accepted');\n\t        }\n\t      } else {\n\t        this.buffer = buffer$$1;\n\t      }\n\n\t      this.position = buffer$$1.length;\n\t    } else {\n\t      if (typeof Buffer$3 !== 'undefined') {\n\t        this.buffer = Buffer$3.alloc(Binary.BUFFER_SIZE);\n\t      } else if (typeof Uint8Array !== 'undefined') {\n\t        this.buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE));\n\t      } else {\n\t        this.buffer = new Array(Binary.BUFFER_SIZE);\n\t      }\n\t    }\n\t  }\n\t  /**\n\t   * Updates this binary with byte_value.\n\t   *\n\t   * @method\n\t   * @param {string} byte_value a single byte we wish to write.\n\t   */\n\n\n\t  _createClass$a(Binary, [{\n\t    key: \"put\",\n\t    value: function put(byte_value) {\n\t      // If it's a string and a has more than one character throw an error\n\t      if (byte_value['length'] != null && typeof byte_value !== 'number' && byte_value.length !== 1) throw new TypeError('only accepts single character String, Uint8Array or Array');\n\t      if (typeof byte_value !== 'number' && byte_value < 0 || byte_value > 255) throw new TypeError('only accepts number in a valid unsigned byte range 0-255'); // Decode the byte value once\n\n\t      var decoded_byte = null;\n\n\t      if (typeof byte_value === 'string') {\n\t        decoded_byte = byte_value.charCodeAt(0);\n\t      } else if (byte_value['length'] != null) {\n\t        decoded_byte = byte_value[0];\n\t      } else {\n\t        decoded_byte = byte_value;\n\t      }\n\n\t      if (this.buffer.length > this.position) {\n\t        this.buffer[this.position++] = decoded_byte;\n\t      } else {\n\t        if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer)) {\n\t          // Create additional overflow buffer\n\t          var buffer$$1 = Buffer$3.alloc(Binary.BUFFER_SIZE + this.buffer.length); // Combine the two buffers together\n\n\t          this.buffer.copy(buffer$$1, 0, 0, this.buffer.length);\n\t          this.buffer = buffer$$1;\n\t          this.buffer[this.position++] = decoded_byte;\n\t        } else {\n\t          var _buffer = null; // Create a new buffer (typed or normal array)\n\n\t          if (isUint8Array(this.buffer)) {\n\t            _buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE + this.buffer.length));\n\t          } else {\n\t            _buffer = new Array(Binary.BUFFER_SIZE + this.buffer.length);\n\t          } // We need to copy all the content to the new array\n\n\n\t          for (var i = 0; i < this.buffer.length; i++) {\n\t            _buffer[i] = this.buffer[i];\n\t          } // Reassign the buffer\n\n\n\t          this.buffer = _buffer; // Write the byte\n\n\t          this.buffer[this.position++] = decoded_byte;\n\t        }\n\t      }\n\t    }\n\t    /**\n\t     * Writes a buffer or string to the binary.\n\t     *\n\t     * @method\n\t     * @param {(Buffer|string)} string a string or buffer to be written to the Binary BSON object.\n\t     * @param {number} offset specify the binary of where to write the content.\n\t     * @return {null}\n\t     */\n\n\t  }, {\n\t    key: \"write\",\n\t    value: function write(string, offset) {\n\t      offset = typeof offset === 'number' ? offset : this.position; // If the buffer is to small let's extend the buffer\n\n\t      if (this.buffer.length < offset + string.length) {\n\t        var buffer$$1 = null; // If we are in node.js\n\n\t        if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer)) {\n\t          buffer$$1 = Buffer$3.alloc(this.buffer.length + string.length);\n\t          this.buffer.copy(buffer$$1, 0, 0, this.buffer.length);\n\t        } else if (isUint8Array(this.buffer)) {\n\t          // Create a new buffer\n\t          buffer$$1 = new Uint8Array(new ArrayBuffer(this.buffer.length + string.length)); // Copy the content\n\n\t          for (var i = 0; i < this.position; i++) {\n\t            buffer$$1[i] = this.buffer[i];\n\t          }\n\t        } // Assign the new buffer\n\n\n\t        this.buffer = buffer$$1;\n\t      }\n\n\t      if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(string) && Buffer$3.isBuffer(this.buffer)) {\n\t        string.copy(this.buffer, offset, 0, string.length);\n\t        this.position = offset + string.length > this.position ? offset + string.length : this.position; // offset = string.length\n\t      } else if (typeof Buffer$3 !== 'undefined' && typeof string === 'string' && Buffer$3.isBuffer(this.buffer)) {\n\t        this.buffer.write(string, offset, 'binary');\n\t        this.position = offset + string.length > this.position ? offset + string.length : this.position; // offset = string.length;\n\t      } else if (isUint8Array(string) || Array.isArray(string) && typeof string !== 'string') {\n\t        for (var _i = 0; _i < string.length; _i++) {\n\t          this.buffer[offset++] = string[_i];\n\t        }\n\n\t        this.position = offset > this.position ? offset : this.position;\n\t      } else if (typeof string === 'string') {\n\t        for (var _i2 = 0; _i2 < string.length; _i2++) {\n\t          this.buffer[offset++] = string.charCodeAt(_i2);\n\t        }\n\n\t        this.position = offset > this.position ? offset : this.position;\n\t      }\n\t    }\n\t    /**\n\t     * Reads **length** bytes starting at **position**.\n\t     *\n\t     * @method\n\t     * @param {number} position read from the given position in the Binary.\n\t     * @param {number} length the number of bytes to read.\n\t     * @return {Buffer}\n\t     */\n\n\t  }, {\n\t    key: \"read\",\n\t    value: function read(position, length) {\n\t      length = length && length > 0 ? length : this.position; // Let's return the data based on the type we have\n\n\t      if (this.buffer['slice']) {\n\t        return this.buffer.slice(position, position + length);\n\t      } // Create a buffer to keep the result\n\n\n\t      var buffer$$1 = typeof Uint8Array !== 'undefined' ? new Uint8Array(new ArrayBuffer(length)) : new Array(length);\n\n\t      for (var i = 0; i < length; i++) {\n\t        buffer$$1[i] = this.buffer[position++];\n\t      } // Return the buffer\n\n\n\t      return buffer$$1;\n\t    }\n\t    /**\n\t     * Returns the value of this binary as a string.\n\t     *\n\t     * @method\n\t     * @return {string}\n\t     */\n\n\t  }, {\n\t    key: \"value\",\n\t    value: function value(asRaw) {\n\t      asRaw = asRaw == null ? false : asRaw; // Optimize to serialize for the situation where the data == size of buffer\n\n\t      if (asRaw && typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer) && this.buffer.length === this.position) return this.buffer; // If it's a node.js buffer object\n\n\t      if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer)) {\n\t        return asRaw ? this.buffer.slice(0, this.position) : this.buffer.toString('binary', 0, this.position);\n\t      } else {\n\t        if (asRaw) {\n\t          // we support the slice command use it\n\t          if (this.buffer['slice'] != null) {\n\t            return this.buffer.slice(0, this.position);\n\t          } else {\n\t            // Create a new buffer to copy content to\n\t            var newBuffer = isUint8Array(this.buffer) ? new Uint8Array(new ArrayBuffer(this.position)) : new Array(this.position); // Copy content\n\n\t            for (var i = 0; i < this.position; i++) {\n\t              newBuffer[i] = this.buffer[i];\n\t            } // Return the buffer\n\n\n\t            return newBuffer;\n\t          }\n\t        } else {\n\t          return convertArraytoUtf8BinaryString(this.buffer, 0, this.position);\n\t        }\n\t      }\n\t    }\n\t    /**\n\t     * Length.\n\t     *\n\t     * @method\n\t     * @return {number} the length of the binary.\n\t     */\n\n\t  }, {\n\t    key: \"length\",\n\t    value: function length() {\n\t      return this.position;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.buffer != null ? this.buffer.toString('base64') : '';\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toString\",\n\t    value: function toString(format) {\n\t      return this.buffer != null ? this.buffer.slice(0, this.position).toString(format) : '';\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      var base64String = Buffer$3.isBuffer(this.buffer) ? this.buffer.toString('base64') : Buffer$3.from(this.buffer).toString('base64');\n\t      var subType = Number(this.sub_type).toString(16);\n\t      return {\n\t        $binary: {\n\t          base64: base64String,\n\t          subType: subType.length === 1 ? '0' + subType : subType\n\t        }\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      var type = doc.$binary.subType ? parseInt(doc.$binary.subType, 16) : 0;\n\t      var data = Buffer$3.from(doc.$binary.base64, 'base64');\n\t      return new Binary(data, type);\n\t    }\n\t  }]);\n\n\t  return Binary;\n\t}();\n\t/**\n\t * Binary default subtype\n\t * @ignore\n\t */\n\n\n\tvar BSON_BINARY_SUBTYPE_DEFAULT = 0;\n\n\tfunction isUint8Array(obj) {\n\t  return Object.prototype.toString.call(obj) === '[object Uint8Array]';\n\t}\n\t/**\n\t * @ignore\n\t */\n\n\n\tfunction writeStringToArray(data) {\n\t  // Create a buffer\n\t  var buffer$$1 = typeof Uint8Array !== 'undefined' ? new Uint8Array(new ArrayBuffer(data.length)) : new Array(data.length); // Write the content to the buffer\n\n\t  for (var i = 0; i < data.length; i++) {\n\t    buffer$$1[i] = data.charCodeAt(i);\n\t  } // Write the string to the buffer\n\n\n\t  return buffer$$1;\n\t}\n\t/**\n\t * Convert Array ot Uint8Array to Binary String\n\t *\n\t * @ignore\n\t */\n\n\n\tfunction convertArraytoUtf8BinaryString(byteArray, startIndex, endIndex) {\n\t  var result = '';\n\n\t  for (var i = startIndex; i < endIndex; i++) {\n\t    result = result + String.fromCharCode(byteArray[i]);\n\t  }\n\n\t  return result;\n\t}\n\n\tBinary.BUFFER_SIZE = 256;\n\t/**\n\t * Default BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_DEFAULT = 0;\n\t/**\n\t * Function BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_FUNCTION = 1;\n\t/**\n\t * Byte Array BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_BYTE_ARRAY = 2;\n\t/**\n\t * OLD UUID BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_UUID_OLD = 3;\n\t/**\n\t * UUID BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_UUID = 4;\n\t/**\n\t * MD5 BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_MD5 = 5;\n\t/**\n\t * User BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_USER_DEFINED = 128;\n\tObject.defineProperty(Binary.prototype, '_bsontype', {\n\t  value: 'Binary'\n\t});\n\tvar binary = Binary;\n\n\tvar constants = {\n\t  // BSON MAX VALUES\n\t  BSON_INT32_MAX: 0x7fffffff,\n\t  BSON_INT32_MIN: -0x80000000,\n\t  BSON_INT64_MAX: Math.pow(2, 63) - 1,\n\t  BSON_INT64_MIN: -Math.pow(2, 63),\n\t  // JS MAX PRECISE VALUES\n\t  JS_INT_MAX: 0x20000000000000,\n\t  // Any integer up to 2^53 can be precisely represented by a double.\n\t  JS_INT_MIN: -0x20000000000000,\n\t  // Any integer down to -2^53 can be precisely represented by a double.\n\n\t  /**\n\t   * Number BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_NUMBER\n\t   **/\n\t  BSON_DATA_NUMBER: 1,\n\n\t  /**\n\t   * String BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_STRING\n\t   **/\n\t  BSON_DATA_STRING: 2,\n\n\t  /**\n\t   * Object BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_OBJECT\n\t   **/\n\t  BSON_DATA_OBJECT: 3,\n\n\t  /**\n\t   * Array BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_ARRAY\n\t   **/\n\t  BSON_DATA_ARRAY: 4,\n\n\t  /**\n\t   * Binary BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_BINARY\n\t   **/\n\t  BSON_DATA_BINARY: 5,\n\n\t  /**\n\t   * Binary BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_UNDEFINED\n\t   **/\n\t  BSON_DATA_UNDEFINED: 6,\n\n\t  /**\n\t   * ObjectId BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_OID\n\t   **/\n\t  BSON_DATA_OID: 7,\n\n\t  /**\n\t   * Boolean BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_BOOLEAN\n\t   **/\n\t  BSON_DATA_BOOLEAN: 8,\n\n\t  /**\n\t   * Date BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_DATE\n\t   **/\n\t  BSON_DATA_DATE: 9,\n\n\t  /**\n\t   * null BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_NULL\n\t   **/\n\t  BSON_DATA_NULL: 10,\n\n\t  /**\n\t   * RegExp BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_REGEXP\n\t   **/\n\t  BSON_DATA_REGEXP: 11,\n\n\t  /**\n\t   * Code BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_DBPOINTER\n\t   **/\n\t  BSON_DATA_DBPOINTER: 12,\n\n\t  /**\n\t   * Code BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_CODE\n\t   **/\n\t  BSON_DATA_CODE: 13,\n\n\t  /**\n\t   * Symbol BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_SYMBOL\n\t   **/\n\t  BSON_DATA_SYMBOL: 14,\n\n\t  /**\n\t   * Code with Scope BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_CODE_W_SCOPE\n\t   **/\n\t  BSON_DATA_CODE_W_SCOPE: 15,\n\n\t  /**\n\t   * 32 bit Integer BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_INT\n\t   **/\n\t  BSON_DATA_INT: 16,\n\n\t  /**\n\t   * Timestamp BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_TIMESTAMP\n\t   **/\n\t  BSON_DATA_TIMESTAMP: 17,\n\n\t  /**\n\t   * Long BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_LONG\n\t   **/\n\t  BSON_DATA_LONG: 18,\n\n\t  /**\n\t   * Long BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_DECIMAL128\n\t   **/\n\t  BSON_DATA_DECIMAL128: 19,\n\n\t  /**\n\t   * MinKey BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_MIN_KEY\n\t   **/\n\t  BSON_DATA_MIN_KEY: 0xff,\n\n\t  /**\n\t   * MaxKey BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_MAX_KEY\n\t   **/\n\t  BSON_DATA_MAX_KEY: 0x7f,\n\n\t  /**\n\t   * Binary Default Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_DEFAULT\n\t   **/\n\t  BSON_BINARY_SUBTYPE_DEFAULT: 0,\n\n\t  /**\n\t   * Binary Function Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_FUNCTION\n\t   **/\n\t  BSON_BINARY_SUBTYPE_FUNCTION: 1,\n\n\t  /**\n\t   * Binary Byte Array Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_BYTE_ARRAY\n\t   **/\n\t  BSON_BINARY_SUBTYPE_BYTE_ARRAY: 2,\n\n\t  /**\n\t   * Binary UUID Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_UUID\n\t   **/\n\t  BSON_BINARY_SUBTYPE_UUID: 3,\n\n\t  /**\n\t   * Binary MD5 Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_MD5\n\t   **/\n\t  BSON_BINARY_SUBTYPE_MD5: 4,\n\n\t  /**\n\t   * Binary User Defined Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_USER_DEFINED\n\t   **/\n\t  BSON_BINARY_SUBTYPE_USER_DEFINED: 128\n\t};\n\n\tfunction _typeof$2(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$2(obj); }\n\t// const Map = require('./map');\n\n\t/**\n\t * @namespace EJSON\n\t */\n\t// all the types where we don't need to do any special processing and can just pass the EJSON\n\t//straight to type.fromExtendedJSON\n\n\n\tvar keysToCodecs = {\n\t  $oid: objectid,\n\t  $binary: binary,\n\t  $symbol: symbol,\n\t  $numberInt: int_32,\n\t  $numberDecimal: decimal128,\n\t  $numberDouble: double_1,\n\t  $numberLong: long_1,\n\t  $minKey: min_key,\n\t  $maxKey: max_key,\n\t  $regularExpression: regexp,\n\t  $timestamp: timestamp\n\t};\n\n\tfunction deserializeValue(self, key, value, options) {\n\t  if (typeof value === 'number') {\n\t    if (options.relaxed) {\n\t      return value;\n\t    } // if it's an integer, should interpret as smallest BSON integer\n\t    // that can represent it exactly. (if out of range, interpret as double.)\n\n\n\t    if (Math.floor(value) === value) {\n\t      if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) return new int_32(value);\n\t      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) return new long_1.fromNumber(value);\n\t    } // If the number is a non-integer or out of integer range, should interpret as BSON Double.\n\n\n\t    return new double_1(value);\n\t  } // from here on out we're looking for bson types, so bail if its not an object\n\n\n\t  if (value == null || _typeof$2(value) !== 'object') return value; // upgrade deprecated undefined to null\n\n\t  if (value.$undefined) return null;\n\t  var keys = Object.keys(value).filter(function (k) {\n\t    return k.startsWith('$') && value[k] != null;\n\t  });\n\n\t  for (var i = 0; i < keys.length; i++) {\n\t    var c = keysToCodecs[keys[i]];\n\t    if (c) return c.fromExtendedJSON(value, options);\n\t  }\n\n\t  if (value.$date != null) {\n\t    var d = value.$date;\n\t    var date = new Date();\n\t    if (typeof d === 'string') date.setTime(Date.parse(d));else if (long_1.isLong(d)) date.setTime(d.toNumber());else if (typeof d === 'number' && options.relaxed) date.setTime(d);\n\t    return date;\n\t  }\n\n\t  if (value.$code != null) {\n\t    var copy = Object.assign({}, value);\n\n\t    if (value.$scope) {\n\t      copy.$scope = deserializeValue(self, null, value.$scope);\n\t    }\n\n\t    return code.fromExtendedJSON(value);\n\t  }\n\n\t  if (value.$ref != null || value.$dbPointer != null) {\n\t    var v = value.$ref ? value : value.$dbPointer; // we run into this in a \"degenerate EJSON\" case (with $id and $ref order flipped)\n\t    // because of the order JSON.parse goes through the document\n\n\t    if (v instanceof db_ref) return v;\n\t    var dollarKeys = Object.keys(v).filter(function (k) {\n\t      return k.startsWith('$');\n\t    });\n\t    var valid = true;\n\t    dollarKeys.forEach(function (k) {\n\t      if (['$ref', '$id', '$db'].indexOf(k) === -1) valid = false;\n\t    }); // only make DBRef if $ keys are all valid\n\n\t    if (valid) return db_ref.fromExtendedJSON(v);\n\t  }\n\n\t  return value;\n\t}\n\t/**\n\t * Parse an Extended JSON string, constructing the JavaScript value or object described by that\n\t * string.\n\t *\n\t * @memberof EJSON\n\t * @param {string} text\n\t * @param {object} [options] Optional settings\n\t * @param {boolean} [options.relaxed=true] Attempt to return native JS types where possible, rather than BSON types (if true)\n\t * @return {object}\n\t *\n\t * @example\n\t * const { EJSON } = require('bson');\n\t * const text = '{ \"int32\": { \"$numberInt\": \"10\" } }';\n\t *\n\t * // prints { int32: { [String: '10'] _bsontype: 'Int32', value: '10' } }\n\t * console.log(EJSON.parse(text, { relaxed: false }));\n\t *\n\t * // prints { int32: 10 }\n\t * console.log(EJSON.parse(text));\n\t */\n\n\n\tfunction parse(text, options) {\n\t  var _this = this;\n\n\t  options = Object.assign({}, {\n\t    relaxed: true\n\t  }, options); // relaxed implies not strict\n\n\t  if (typeof options.relaxed === 'boolean') options.strict = !options.relaxed;\n\t  if (typeof options.strict === 'boolean') options.relaxed = !options.strict;\n\t  return JSON.parse(text, function (key, value) {\n\t    return deserializeValue(_this, key, value, options);\n\t  });\n\t} //\n\t// Serializer\n\t//\n\t// MAX INT32 boundaries\n\n\n\tvar BSON_INT32_MAX = 0x7fffffff,\n\t    BSON_INT32_MIN = -0x80000000,\n\t    BSON_INT64_MAX = 0x7fffffffffffffff,\n\t    BSON_INT64_MIN = -0x8000000000000000;\n\t/**\n\t * Converts a BSON document to an Extended JSON string, optionally replacing values if a replacer\n\t * function is specified or optionally including only the specified properties if a replacer array\n\t * is specified.\n\t *\n\t * @memberof EJSON\n\t * @param {object} value The value to convert to extended JSON\n\t * @param {function|array} [replacer] A function that alters the behavior of the stringification process, or an array of String and Number objects that serve as a whitelist for selecting/filtering the properties of the value object to be included in the JSON string. If this value is null or not provided, all properties of the object are included in the resulting JSON string\n\t * @param {string|number} [space] A String or Number object that's used to insert white space into the output JSON string for readability purposes.\n\t * @param {object} [options] Optional settings\n\t * @param {boolean} [options.relaxed=true] Enabled Extended JSON's `relaxed` mode\n\t * @returns {string}\n\t *\n\t * @example\n\t * const { EJSON } = require('bson');\n\t * const Int32 = require('mongodb').Int32;\n\t * const doc = { int32: new Int32(10) };\n\t *\n\t * // prints '{\"int32\":{\"$numberInt\":\"10\"}}'\n\t * console.log(EJSON.stringify(doc, { relaxed: false }));\n\t *\n\t * // prints '{\"int32\":10}'\n\t * console.log(EJSON.stringify(doc));\n\t */\n\n\tfunction stringify(value, replacer, space, options) {\n\t  if (space != null && _typeof$2(space) === 'object') {\n\t    options = space;\n\t    space = 0;\n\t  }\n\n\t  if (replacer != null && _typeof$2(replacer) === 'object' && !Array.isArray(replacer)) {\n\t    options = replacer;\n\t    replacer = null;\n\t    space = 0;\n\t  }\n\n\t  options = Object.assign({}, {\n\t    relaxed: true\n\t  }, options);\n\t  var doc = Array.isArray(value) ? serializeArray(value, options) : serializeDocument(value, options);\n\t  return JSON.stringify(doc, replacer, space);\n\t}\n\t/**\n\t * Serializes an object to an Extended JSON string, and reparse it as a JavaScript object.\n\t *\n\t * @memberof EJSON\n\t * @param {object} bson The object to serialize\n\t * @param {object} [options] Optional settings passed to the `stringify` function\n\t * @return {object}\n\t */\n\n\n\tfunction serialize(bson, options) {\n\t  options = options || {};\n\t  return JSON.parse(stringify(bson, options));\n\t}\n\t/**\n\t * Deserializes an Extended JSON object into a plain JavaScript object with native/BSON types\n\t *\n\t * @memberof EJSON\n\t * @param {object} ejson The Extended JSON object to deserialize\n\t * @param {object} [options] Optional settings passed to the parse method\n\t * @return {object}\n\t */\n\n\n\tfunction deserialize(ejson, options) {\n\t  options = options || {};\n\t  return parse(JSON.stringify(ejson), options);\n\t}\n\n\tfunction serializeArray(array, options) {\n\t  return array.map(function (v) {\n\t    return serializeValue(v, options);\n\t  });\n\t}\n\n\tfunction getISOString(date) {\n\t  var isoStr = date.toISOString(); // we should only show milliseconds in timestamp if they're non-zero\n\n\t  return date.getUTCMilliseconds() !== 0 ? isoStr : isoStr.slice(0, -5) + 'Z';\n\t}\n\n\tfunction serializeValue(value, options) {\n\t  if (Array.isArray(value)) return serializeArray(value, options);\n\t  if (value === undefined) return null;\n\n\t  if (value instanceof Date) {\n\t    var dateNum = value.getTime(),\n\t        // is it in year range 1970-9999?\n\t    inRange = dateNum > -1 && dateNum < 253402318800000;\n\t    return options.relaxed && inRange ? {\n\t      $date: getISOString(value)\n\t    } : {\n\t      $date: {\n\t        $numberLong: value.getTime().toString()\n\t      }\n\t    };\n\t  }\n\n\t  if (typeof value === 'number' && !options.relaxed) {\n\t    // it's an integer\n\t    if (Math.floor(value) === value) {\n\t      var int32Range = value >= BSON_INT32_MIN && value <= BSON_INT32_MAX,\n\t          int64Range = value >= BSON_INT64_MIN && value <= BSON_INT64_MAX; // interpret as being of the smallest BSON integer type that can represent the number exactly\n\n\t      if (int32Range) return {\n\t        $numberInt: value.toString()\n\t      };\n\t      if (int64Range) return {\n\t        $numberLong: value.toString()\n\t      };\n\t    }\n\n\t    return {\n\t      $numberDouble: value.toString()\n\t    };\n\t  }\n\n\t  if (value instanceof RegExp) {\n\t    var flags = value.flags;\n\n\t    if (flags === undefined) {\n\t      flags = value.toString().match(/[gimuy]*$/)[0];\n\t    }\n\n\t    var rx = new regexp(value.source, flags);\n\t    return rx.toExtendedJSON();\n\t  }\n\n\t  if (value != null && _typeof$2(value) === 'object') return serializeDocument(value, options);\n\t  return value;\n\t}\n\n\tvar BSON_TYPE_MAPPINGS = {\n\t  Binary: function Binary(o) {\n\t    return new binary(o.value(), o.subtype);\n\t  },\n\t  Code: function Code(o) {\n\t    return new code(o.code, o.scope);\n\t  },\n\t  DBRef: function DBRef(o) {\n\t    return new db_ref(o.collection || o.namespace, o.oid, o.db, o.fields);\n\t  },\n\t  // \"namespace\" for 1.x library backwards compat\n\t  Decimal128: function Decimal128(o) {\n\t    return new decimal128(o.bytes);\n\t  },\n\t  Double: function Double(o) {\n\t    return new double_1(o.value);\n\t  },\n\t  Int32: function Int32(o) {\n\t    return new int_32(o.value);\n\t  },\n\t  Long: function Long(o) {\n\t    return long_1.fromBits( // underscore variants for 1.x backwards compatibility\n\t    o.low != null ? o.low : o.low_, o.low != null ? o.high : o.high_, o.low != null ? o.unsigned : o.unsigned_);\n\t  },\n\t  MaxKey: function MaxKey() {\n\t    return new max_key();\n\t  },\n\t  MinKey: function MinKey() {\n\t    return new min_key();\n\t  },\n\t  ObjectID: function ObjectID(o) {\n\t    return new objectid(o);\n\t  },\n\t  ObjectId: function ObjectId(o) {\n\t    return new objectid(o);\n\t  },\n\t  // support 4.0.0/4.0.1 before _bsontype was reverted back to ObjectID\n\t  BSONRegExp: function BSONRegExp(o) {\n\t    return new regexp(o.pattern, o.options);\n\t  },\n\t  Symbol: function Symbol(o) {\n\t    return new symbol(o.value);\n\t  },\n\t  Timestamp: function Timestamp(o) {\n\t    return timestamp.fromBits(o.low, o.high);\n\t  }\n\t};\n\n\tfunction serializeDocument(doc, options) {\n\t  if (doc == null || _typeof$2(doc) !== 'object') throw new Error('not an object instance');\n\t  var bsontype = doc._bsontype;\n\n\t  if (typeof bsontype === 'undefined') {\n\t    // It's a regular object. Recursively serialize its property values.\n\t    var _doc = {};\n\n\t    for (var name in doc) {\n\t      _doc[name] = serializeValue(doc[name], options);\n\t    }\n\n\t    return _doc;\n\t  } else if (typeof bsontype === 'string') {\n\t    // the \"document\" is really just a BSON type object\n\t    var _doc2 = doc;\n\n\t    if (typeof _doc2.toExtendedJSON !== 'function') {\n\t      // There's no EJSON serialization function on the object. It's probably an\n\t      // object created by a previous version of this library (or another library)\n\t      // that's duck-typing objects to look like they were generated by this library).\n\t      // Copy the object into this library's version of that type.\n\t      var mapper = BSON_TYPE_MAPPINGS[bsontype];\n\n\t      if (!mapper) {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + bsontype);\n\t      }\n\n\t      _doc2 = mapper(_doc2);\n\t    } // Two BSON types may have nested objects that may need to be serialized too\n\n\n\t    if (bsontype === 'Code' && _doc2.scope) {\n\t      _doc2 = new code(_doc2.code, serializeValue(_doc2.scope, options));\n\t    } else if (bsontype === 'DBRef' && _doc2.oid) {\n\t      _doc2 = new db_ref(_doc2.collection, serializeValue(_doc2.oid, options), _doc2.db, _doc2.fields);\n\t    }\n\n\t    return _doc2.toExtendedJSON(options);\n\t  } else {\n\t    throw new Error('_bsontype must be a string, but was: ' + _typeof$2(bsontype));\n\t  }\n\t}\n\n\tvar extended_json = {\n\t  parse: parse,\n\t  deserialize: deserialize,\n\t  serialize: serialize,\n\t  stringify: stringify\n\t};\n\n\tvar FIRST_BIT = 0x80;\n\tvar FIRST_TWO_BITS = 0xc0;\n\tvar FIRST_THREE_BITS = 0xe0;\n\tvar FIRST_FOUR_BITS = 0xf0;\n\tvar FIRST_FIVE_BITS = 0xf8;\n\tvar TWO_BIT_CHAR = 0xc0;\n\tvar THREE_BIT_CHAR = 0xe0;\n\tvar FOUR_BIT_CHAR = 0xf0;\n\tvar CONTINUING_CHAR = 0x80;\n\t/**\n\t * Determines if the passed in bytes are valid utf8\n\t * @param {Buffer|Uint8Array} bytes An array of 8-bit bytes. Must be indexable and have length property\n\t * @param {Number} start The index to start validating\n\t * @param {Number} end The index to end validating\n\t * @returns {boolean} True if valid utf8\n\t */\n\n\tfunction validateUtf8(bytes, start, end) {\n\t  var continuation = 0;\n\n\t  for (var i = start; i < end; i += 1) {\n\t    var byte = bytes[i];\n\n\t    if (continuation) {\n\t      if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {\n\t        return false;\n\t      }\n\n\t      continuation -= 1;\n\t    } else if (byte & FIRST_BIT) {\n\t      if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {\n\t        continuation = 1;\n\t      } else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {\n\t        continuation = 2;\n\t      } else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {\n\t        continuation = 3;\n\t      } else {\n\t        return false;\n\t      }\n\t    }\n\t  }\n\n\t  return !continuation;\n\t}\n\n\tvar validateUtf8_1 = validateUtf8;\n\tvar validate_utf8 = {\n\t  validateUtf8: validateUtf8_1\n\t};\n\n\tvar Buffer$4 = buffer.Buffer;\n\tvar validateUtf8$1 = validate_utf8.validateUtf8; // Internal long versions\n\n\tvar JS_INT_MAX_LONG = long_1.fromNumber(constants.JS_INT_MAX);\n\tvar JS_INT_MIN_LONG = long_1.fromNumber(constants.JS_INT_MIN);\n\tvar functionCache = {};\n\n\tfunction deserialize$1(buffer$$1, options, isArray) {\n\t  options = options == null ? {} : options;\n\t  var index = options && options.index ? options.index : 0; // Read the document size\n\n\t  var size = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24;\n\n\t  if (size < 5) {\n\t    throw new Error(\"bson size must be >= 5, is \".concat(size));\n\t  }\n\n\t  if (options.allowObjectSmallerThanBufferSize && buffer$$1.length < size) {\n\t    throw new Error(\"buffer length \".concat(buffer$$1.length, \" must be >= bson size \").concat(size));\n\t  }\n\n\t  if (!options.allowObjectSmallerThanBufferSize && buffer$$1.length !== size) {\n\t    throw new Error(\"buffer length \".concat(buffer$$1.length, \" must === bson size \").concat(size));\n\t  }\n\n\t  if (size + index > buffer$$1.length) {\n\t    throw new Error(\"(bson size \".concat(size, \" + options.index \").concat(index, \" must be <= buffer length \").concat(Buffer$4.byteLength(buffer$$1), \")\"));\n\t  } // Illegal end value\n\n\n\t  if (buffer$$1[index + size - 1] !== 0) {\n\t    throw new Error(\"One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00\");\n\t  } // Start deserializtion\n\n\n\t  return deserializeObject(buffer$$1, index, options, isArray);\n\t}\n\n\tfunction deserializeObject(buffer$$1, index, options, isArray) {\n\t  var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];\n\t  var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];\n\t  var cacheFunctionsCrc32 = options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];\n\t  if (!cacheFunctionsCrc32) var crc32 = null;\n\t  var fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw']; // Return raw bson buffer instead of parsing it\n\n\t  var raw = options['raw'] == null ? false : options['raw']; // Return BSONRegExp objects instead of native regular expressions\n\n\t  var bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false; // Controls the promotion of values vs wrapper classes\n\n\t  var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];\n\t  var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];\n\t  var promoteValues = options['promoteValues'] == null ? true : options['promoteValues']; // Set the start index\n\n\t  var startIndex = index; // Validate that we have at least 4 bytes of buffer\n\n\t  if (buffer$$1.length < 5) throw new Error('corrupt bson message < 5 bytes long'); // Read the document size\n\n\t  var size = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Ensure buffer is valid size\n\n\t  if (size < 5 || size > buffer$$1.length) throw new Error('corrupt bson message'); // Create holding object\n\n\t  var object = isArray ? [] : {}; // Used for arrays to skip having to perform utf8 decoding\n\n\t  var arrayIndex = 0;\n\t  var done = false; // While we have more left data left keep parsing\n\n\t  while (!done) {\n\t    // Read the type\n\t    var elementType = buffer$$1[index++]; // If we get a zero it's the last byte, exit\n\n\t    if (elementType === 0) break; // Get the start search index\n\n\t    var i = index; // Locate the end of the c string\n\n\t    while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t      i++;\n\t    } // If are at the end of the buffer there is a problem with the document\n\n\n\t    if (i >= Buffer$4.byteLength(buffer$$1)) throw new Error('Bad BSON Document: illegal CString');\n\t    var name = isArray ? arrayIndex++ : buffer$$1.toString('utf8', index, i);\n\t    index = i + 1;\n\n\t    if (elementType === constants.BSON_DATA_STRING) {\n\t      var stringSize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      if (stringSize <= 0 || stringSize > buffer$$1.length - index || buffer$$1[index + stringSize - 1] !== 0) throw new Error('bad string length in bson');\n\n\t      if (!validateUtf8$1(buffer$$1, index, index + stringSize - 1)) {\n\t        throw new Error('Invalid UTF-8 string in BSON document');\n\t      }\n\n\t      var s = buffer$$1.toString('utf8', index, index + stringSize - 1);\n\t      object[name] = s;\n\t      index = index + stringSize;\n\t    } else if (elementType === constants.BSON_DATA_OID) {\n\t      var oid = Buffer$4.alloc(12);\n\t      buffer$$1.copy(oid, 0, index, index + 12);\n\t      object[name] = new objectid(oid);\n\t      index = index + 12;\n\t    } else if (elementType === constants.BSON_DATA_INT && promoteValues === false) {\n\t      object[name] = new int_32(buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24);\n\t    } else if (elementType === constants.BSON_DATA_INT) {\n\t      object[name] = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t    } else if (elementType === constants.BSON_DATA_NUMBER && promoteValues === false) {\n\t      object[name] = new double_1(buffer$$1.readDoubleLE(index));\n\t      index = index + 8;\n\t    } else if (elementType === constants.BSON_DATA_NUMBER) {\n\t      object[name] = buffer$$1.readDoubleLE(index);\n\t      index = index + 8;\n\t    } else if (elementType === constants.BSON_DATA_DATE) {\n\t      var lowBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      var highBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      object[name] = new Date(new long_1(lowBits, highBits).toNumber());\n\t    } else if (elementType === constants.BSON_DATA_BOOLEAN) {\n\t      if (buffer$$1[index] !== 0 && buffer$$1[index] !== 1) throw new Error('illegal boolean type value');\n\t      object[name] = buffer$$1[index++] === 1;\n\t    } else if (elementType === constants.BSON_DATA_OBJECT) {\n\t      var _index = index;\n\t      var objectSize = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24;\n\t      if (objectSize <= 0 || objectSize > buffer$$1.length - index) throw new Error('bad embedded document length in bson'); // We have a raw value\n\n\t      if (raw) {\n\t        object[name] = buffer$$1.slice(index, index + objectSize);\n\t      } else {\n\t        object[name] = deserializeObject(buffer$$1, _index, options, false);\n\t      }\n\n\t      index = index + objectSize;\n\t    } else if (elementType === constants.BSON_DATA_ARRAY) {\n\t      var _index2 = index;\n\n\t      var _objectSize = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24;\n\n\t      var arrayOptions = options; // Stop index\n\n\t      var stopIndex = index + _objectSize; // All elements of array to be returned as raw bson\n\n\t      if (fieldsAsRaw && fieldsAsRaw[name]) {\n\t        arrayOptions = {};\n\n\t        for (var n in options) {\n\t          arrayOptions[n] = options[n];\n\t        }\n\n\t        arrayOptions['raw'] = true;\n\t      }\n\n\t      object[name] = deserializeObject(buffer$$1, _index2, arrayOptions, true);\n\t      index = index + _objectSize;\n\t      if (buffer$$1[index - 1] !== 0) throw new Error('invalid array terminator byte');\n\t      if (index !== stopIndex) throw new Error('corrupted array bson');\n\t    } else if (elementType === constants.BSON_DATA_UNDEFINED) {\n\t      object[name] = undefined;\n\t    } else if (elementType === constants.BSON_DATA_NULL) {\n\t      object[name] = null;\n\t    } else if (elementType === constants.BSON_DATA_LONG) {\n\t      // Unpack the low and high bits\n\t      var _lowBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      var _highBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      var long$$1 = new long_1(_lowBits, _highBits); // Promote the long if possible\n\n\t      if (promoteLongs && promoteValues === true) {\n\t        object[name] = long$$1.lessThanOrEqual(JS_INT_MAX_LONG) && long$$1.greaterThanOrEqual(JS_INT_MIN_LONG) ? long$$1.toNumber() : long$$1;\n\t      } else {\n\t        object[name] = long$$1;\n\t      }\n\t    } else if (elementType === constants.BSON_DATA_DECIMAL128) {\n\t      // Buffer to contain the decimal bytes\n\t      var bytes = Buffer$4.alloc(16); // Copy the next 16 bytes into the bytes buffer\n\n\t      buffer$$1.copy(bytes, 0, index, index + 16); // Update index\n\n\t      index = index + 16; // Assign the new Decimal128 value\n\n\t      var decimal128$$1 = new decimal128(bytes); // If we have an alternative mapper use that\n\n\t      object[name] = decimal128$$1.toObject ? decimal128$$1.toObject() : decimal128$$1;\n\t    } else if (elementType === constants.BSON_DATA_BINARY) {\n\t      var binarySize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      var totalBinarySize = binarySize;\n\t      var subType = buffer$$1[index++]; // Did we have a negative binary size, throw\n\n\t      if (binarySize < 0) throw new Error('Negative binary type element size found'); // Is the length longer than the document\n\n\t      if (binarySize > Buffer$4.byteLength(buffer$$1)) throw new Error('Binary type size larger than document size'); // Decode as raw Buffer object if options specifies it\n\n\t      if (buffer$$1['slice'] != null) {\n\t        // If we have subtype 2 skip the 4 bytes for the size\n\t        if (subType === binary.SUBTYPE_BYTE_ARRAY) {\n\t          binarySize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t          if (binarySize < 0) throw new Error('Negative binary type element size found for subtype 0x02');\n\t          if (binarySize > totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to long binary size');\n\t          if (binarySize < totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to short binary size');\n\t        }\n\n\t        if (promoteBuffers && promoteValues) {\n\t          object[name] = buffer$$1.slice(index, index + binarySize);\n\t        } else {\n\t          object[name] = new binary(buffer$$1.slice(index, index + binarySize), subType);\n\t        }\n\t      } else {\n\t        var _buffer = typeof Uint8Array !== 'undefined' ? new Uint8Array(new ArrayBuffer(binarySize)) : new Array(binarySize); // If we have subtype 2 skip the 4 bytes for the size\n\n\n\t        if (subType === binary.SUBTYPE_BYTE_ARRAY) {\n\t          binarySize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t          if (binarySize < 0) throw new Error('Negative binary type element size found for subtype 0x02');\n\t          if (binarySize > totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to long binary size');\n\t          if (binarySize < totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to short binary size');\n\t        } // Copy the data\n\n\n\t        for (i = 0; i < binarySize; i++) {\n\t          _buffer[i] = buffer$$1[index + i];\n\t        }\n\n\t        if (promoteBuffers && promoteValues) {\n\t          object[name] = _buffer;\n\t        } else {\n\t          object[name] = new binary(_buffer, subType);\n\t        }\n\t      } // Update the index\n\n\n\t      index = index + binarySize;\n\t    } else if (elementType === constants.BSON_DATA_REGEXP && bsonRegExp === false) {\n\t      // Get the start search index\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var source = buffer$$1.toString('utf8', index, i); // Create the regexp\n\n\t      index = i + 1; // Get the start search index\n\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var regExpOptions = buffer$$1.toString('utf8', index, i);\n\t      index = i + 1; // For each option add the corresponding one for javascript\n\n\t      var optionsArray = new Array(regExpOptions.length); // Parse options\n\n\t      for (i = 0; i < regExpOptions.length; i++) {\n\t        switch (regExpOptions[i]) {\n\t          case 'm':\n\t            optionsArray[i] = 'm';\n\t            break;\n\n\t          case 's':\n\t            optionsArray[i] = 'g';\n\t            break;\n\n\t          case 'i':\n\t            optionsArray[i] = 'i';\n\t            break;\n\t        }\n\t      }\n\n\t      object[name] = new RegExp(source, optionsArray.join(''));\n\t    } else if (elementType === constants.BSON_DATA_REGEXP && bsonRegExp === true) {\n\t      // Get the start search index\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var _source = buffer$$1.toString('utf8', index, i);\n\n\t      index = i + 1; // Get the start search index\n\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var _regExpOptions = buffer$$1.toString('utf8', index, i);\n\n\t      index = i + 1; // Set the object\n\n\t      object[name] = new regexp(_source, _regExpOptions);\n\t    } else if (elementType === constants.BSON_DATA_SYMBOL) {\n\t      var _stringSize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      if (_stringSize <= 0 || _stringSize > buffer$$1.length - index || buffer$$1[index + _stringSize - 1] !== 0) throw new Error('bad string length in bson'); // symbol is deprecated - upgrade to string.\n\n\t      object[name] = buffer$$1.toString('utf8', index, index + _stringSize - 1);\n\t      index = index + _stringSize;\n\t    } else if (elementType === constants.BSON_DATA_TIMESTAMP) {\n\t      var _lowBits2 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      var _highBits2 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      object[name] = new timestamp(_lowBits2, _highBits2);\n\t    } else if (elementType === constants.BSON_DATA_MIN_KEY) {\n\t      object[name] = new min_key();\n\t    } else if (elementType === constants.BSON_DATA_MAX_KEY) {\n\t      object[name] = new max_key();\n\t    } else if (elementType === constants.BSON_DATA_CODE) {\n\t      var _stringSize2 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      if (_stringSize2 <= 0 || _stringSize2 > buffer$$1.length - index || buffer$$1[index + _stringSize2 - 1] !== 0) throw new Error('bad string length in bson');\n\t      var functionString = buffer$$1.toString('utf8', index, index + _stringSize2 - 1); // If we are evaluating the functions\n\n\t      if (evalFunctions) {\n\t        // If we have cache enabled let's look for the md5 of the function in the cache\n\t        if (cacheFunctions) {\n\t          var hash = cacheFunctionsCrc32 ? crc32(functionString) : functionString; // Got to do this to avoid V8 deoptimizing the call due to finding eval\n\n\t          object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);\n\t        } else {\n\t          object[name] = isolateEval(functionString);\n\t        }\n\t      } else {\n\t        object[name] = new code(functionString);\n\t      } // Update parse index position\n\n\n\t      index = index + _stringSize2;\n\t    } else if (elementType === constants.BSON_DATA_CODE_W_SCOPE) {\n\t      var totalSize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Element cannot be shorter than totalSize + stringSize + documentSize + terminator\n\n\t      if (totalSize < 4 + 4 + 4 + 1) {\n\t        throw new Error('code_w_scope total size shorter minimum expected length');\n\t      } // Get the code string size\n\n\n\t      var _stringSize3 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Check if we have a valid string\n\n\n\t      if (_stringSize3 <= 0 || _stringSize3 > buffer$$1.length - index || buffer$$1[index + _stringSize3 - 1] !== 0) throw new Error('bad string length in bson'); // Javascript function\n\n\t      var _functionString = buffer$$1.toString('utf8', index, index + _stringSize3 - 1); // Update parse index position\n\n\n\t      index = index + _stringSize3; // Parse the element\n\n\t      var _index3 = index; // Decode the size of the object document\n\n\t      var _objectSize2 = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24; // Decode the scope object\n\n\n\t      var scopeObject = deserializeObject(buffer$$1, _index3, options, false); // Adjust the index\n\n\t      index = index + _objectSize2; // Check if field length is to short\n\n\t      if (totalSize < 4 + 4 + _objectSize2 + _stringSize3) {\n\t        throw new Error('code_w_scope total size is to short, truncating scope');\n\t      } // Check if totalSize field is to long\n\n\n\t      if (totalSize > 4 + 4 + _objectSize2 + _stringSize3) {\n\t        throw new Error('code_w_scope total size is to long, clips outer document');\n\t      } // If we are evaluating the functions\n\n\n\t      if (evalFunctions) {\n\t        // If we have cache enabled let's look for the md5 of the function in the cache\n\t        if (cacheFunctions) {\n\t          var _hash = cacheFunctionsCrc32 ? crc32(_functionString) : _functionString; // Got to do this to avoid V8 deoptimizing the call due to finding eval\n\n\n\t          object[name] = isolateEvalWithHash(functionCache, _hash, _functionString, object);\n\t        } else {\n\t          object[name] = isolateEval(_functionString);\n\t        }\n\n\t        object[name].scope = scopeObject;\n\t      } else {\n\t        object[name] = new code(_functionString, scopeObject);\n\t      }\n\t    } else if (elementType === constants.BSON_DATA_DBPOINTER) {\n\t      // Get the code string size\n\t      var _stringSize4 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Check if we have a valid string\n\n\n\t      if (_stringSize4 <= 0 || _stringSize4 > buffer$$1.length - index || buffer$$1[index + _stringSize4 - 1] !== 0) throw new Error('bad string length in bson'); // Namespace\n\n\t      if (!validateUtf8$1(buffer$$1, index, index + _stringSize4 - 1)) {\n\t        throw new Error('Invalid UTF-8 string in BSON document');\n\t      }\n\n\t      var namespace = buffer$$1.toString('utf8', index, index + _stringSize4 - 1); // Update parse index position\n\n\t      index = index + _stringSize4; // Read the oid\n\n\t      var oidBuffer = Buffer$4.alloc(12);\n\t      buffer$$1.copy(oidBuffer, 0, index, index + 12);\n\n\t      var _oid = new objectid(oidBuffer); // Update the index\n\n\n\t      index = index + 12; // Upgrade to DBRef type\n\n\t      object[name] = new db_ref(namespace, _oid);\n\t    } else {\n\t      throw new Error('Detected unknown BSON type ' + elementType.toString(16) + ' for fieldname \"' + name + '\", are you using the latest BSON parser?');\n\t    }\n\t  } // Check if the deserialization was against a valid array/object\n\n\n\t  if (size !== index - startIndex) {\n\t    if (isArray) throw new Error('corrupt array bson');\n\t    throw new Error('corrupt object bson');\n\t  } // check if object's $ keys are those of a DBRef\n\n\n\t  var dollarKeys = Object.keys(object).filter(function (k) {\n\t    return k.startsWith('$');\n\t  });\n\t  var valid = true;\n\t  dollarKeys.forEach(function (k) {\n\t    if (['$ref', '$id', '$db'].indexOf(k) === -1) valid = false;\n\t  }); // if a $key not in \"$ref\", \"$id\", \"$db\", don't make a DBRef\n\n\t  if (!valid) return object;\n\n\t  if (object['$id'] != null && object['$ref'] != null) {\n\t    var copy = Object.assign({}, object);\n\t    delete copy.$ref;\n\t    delete copy.$id;\n\t    delete copy.$db;\n\t    return new db_ref(object.$ref, object.$id, object.$db || null, copy);\n\t  }\n\n\t  return object;\n\t}\n\t/**\n\t * Ensure eval is isolated.\n\t *\n\t * @ignore\n\t * @api private\n\t */\n\n\n\tfunction isolateEvalWithHash(functionCache, hash, functionString, object) {\n\t  // Contains the value we are going to set\n\t  var value = null; // Check for cache hit, eval if missing and return cached function\n\n\t  if (functionCache[hash] == null) {\n\t    eval('value = ' + functionString);\n\t    functionCache[hash] = value;\n\t  } // Set the object\n\n\n\t  return functionCache[hash].bind(object);\n\t}\n\t/**\n\t * Ensure eval is isolated.\n\t *\n\t * @ignore\n\t * @api private\n\t */\n\n\n\tfunction isolateEval(functionString) {\n\t  // Contains the value we are going to set\n\t  var value = null; // Eval the function\n\n\t  eval('value = ' + functionString);\n\t  return value;\n\t}\n\n\tvar deserializer = deserialize$1;\n\n\t// All rights reserved.\n\t//\n\t// Redistribution and use in source and binary forms, with or without\n\t// modification, are permitted provided that the following conditions are met:\n\t//\n\t//  * Redistributions of source code must retain the above copyright notice,\n\t//    this list of conditions and the following disclaimer.\n\t//\n\t//  * Redistributions in binary form must reproduce the above copyright notice,\n\t//    this list of conditions and the following disclaimer in the documentation\n\t//    and/or other materials provided with the distribution.\n\t//\n\t//  * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors\n\t//    may be used to endorse or promote products derived from this software\n\t//    without specific prior written permission.\n\t//\n\t// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n\t// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n\t// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n\t// ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n\t// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n\t// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n\t// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n\t// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n\t// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n\t// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n\t// POSSIBILITY OF SUCH DAMAGE.\n\t//\n\t//\n\t// Modifications to writeIEEE754 to support negative zeroes made by Brian White\n\n\tfunction readIEEE754(buffer$$1, offset, endian, mLen, nBytes) {\n\t  var e,\n\t      m,\n\t      bBE = endian === 'big',\n\t      eLen = nBytes * 8 - mLen - 1,\n\t      eMax = (1 << eLen) - 1,\n\t      eBias = eMax >> 1,\n\t      nBits = -7,\n\t      i = bBE ? 0 : nBytes - 1,\n\t      d = bBE ? 1 : -1,\n\t      s = buffer$$1[offset + i];\n\t  i += d;\n\t  e = s & (1 << -nBits) - 1;\n\t  s >>= -nBits;\n\t  nBits += eLen;\n\n\t  for (; nBits > 0; e = e * 256 + buffer$$1[offset + i], i += d, nBits -= 8) {\n\t  }\n\n\t  m = e & (1 << -nBits) - 1;\n\t  e >>= -nBits;\n\t  nBits += mLen;\n\n\t  for (; nBits > 0; m = m * 256 + buffer$$1[offset + i], i += d, nBits -= 8) {\n\t  }\n\n\t  if (e === 0) {\n\t    e = 1 - eBias;\n\t  } else if (e === eMax) {\n\t    return m ? NaN : (s ? -1 : 1) * Infinity;\n\t  } else {\n\t    m = m + Math.pow(2, mLen);\n\t    e = e - eBias;\n\t  }\n\n\t  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n\t}\n\n\tfunction writeIEEE754(buffer$$1, value, offset, endian, mLen, nBytes) {\n\t  var e,\n\t      m,\n\t      c,\n\t      bBE = endian === 'big',\n\t      eLen = nBytes * 8 - mLen - 1,\n\t      eMax = (1 << eLen) - 1,\n\t      eBias = eMax >> 1,\n\t      rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0,\n\t      i = bBE ? nBytes - 1 : 0,\n\t      d = bBE ? -1 : 1,\n\t      s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n\t  value = Math.abs(value);\n\n\t  if (isNaN(value) || value === Infinity) {\n\t    m = isNaN(value) ? 1 : 0;\n\t    e = eMax;\n\t  } else {\n\t    e = Math.floor(Math.log(value) / Math.LN2);\n\n\t    if (value * (c = Math.pow(2, -e)) < 1) {\n\t      e--;\n\t      c *= 2;\n\t    }\n\n\t    if (e + eBias >= 1) {\n\t      value += rt / c;\n\t    } else {\n\t      value += rt * Math.pow(2, 1 - eBias);\n\t    }\n\n\t    if (value * c >= 2) {\n\t      e++;\n\t      c /= 2;\n\t    }\n\n\t    if (e + eBias >= eMax) {\n\t      m = 0;\n\t      e = eMax;\n\t    } else if (e + eBias >= 1) {\n\t      m = (value * c - 1) * Math.pow(2, mLen);\n\t      e = e + eBias;\n\t    } else {\n\t      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n\t      e = 0;\n\t    }\n\t  }\n\n\t  if (isNaN(value)) m = 0;\n\n\t  while (mLen >= 8) {\n\t    buffer$$1[offset + i] = m & 0xff;\n\t    i += d;\n\t    m /= 256;\n\t    mLen -= 8;\n\t  }\n\n\t  e = e << mLen | m;\n\t  if (isNaN(value)) e += 8;\n\t  eLen += mLen;\n\n\t  while (eLen > 0) {\n\t    buffer$$1[offset + i] = e & 0xff;\n\t    i += d;\n\t    e /= 256;\n\t    eLen -= 8;\n\t  }\n\n\t  buffer$$1[offset + i - d] |= s * 128;\n\t}\n\n\tvar float_parser = {\n\t  readIEEE754: readIEEE754,\n\t  writeIEEE754: writeIEEE754\n\t};\n\n\tfunction _typeof$3(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$3(obj); }\n\n\tvar Buffer$5 = buffer.Buffer;\n\tvar writeIEEE754$1 = float_parser.writeIEEE754;\n\tvar normalizedFunctionString$1 = utils.normalizedFunctionString;\n\tvar regexp$1 = /\\x00/; // eslint-disable-line no-control-regex\n\n\tvar ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']); // To ensure that 0.4 of node works correctly\n\n\tvar isDate$1 = function isDate(d) {\n\t  return _typeof$3(d) === 'object' && Object.prototype.toString.call(d) === '[object Date]';\n\t};\n\n\tvar isRegExp$1 = function isRegExp(d) {\n\t  return Object.prototype.toString.call(d) === '[object RegExp]';\n\t};\n\n\tfunction serializeString(buffer$$1, key, value, index, isArray) {\n\t  // Encode String type\n\t  buffer$$1[index++] = constants.BSON_DATA_STRING; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes + 1;\n\t  buffer$$1[index - 1] = 0; // Write the string\n\n\t  var size = buffer$$1.write(value, index + 4, 'utf8'); // Write the size of the string to buffer\n\n\t  buffer$$1[index + 3] = size + 1 >> 24 & 0xff;\n\t  buffer$$1[index + 2] = size + 1 >> 16 & 0xff;\n\t  buffer$$1[index + 1] = size + 1 >> 8 & 0xff;\n\t  buffer$$1[index] = size + 1 & 0xff; // Update index\n\n\t  index = index + 4 + size; // Write zero\n\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeNumber(buffer$$1, key, value, index, isArray) {\n\t  // We have an integer value\n\t  if (Math.floor(value) === value && value >= constants.JS_INT_MIN && value <= constants.JS_INT_MAX) {\n\t    // If the value fits in 32 bits encode as int, if it fits in a double\n\t    // encode it as a double, otherwise long\n\t    if (value >= constants.BSON_INT32_MIN && value <= constants.BSON_INT32_MAX) {\n\t      // Set int type 32 bits or less\n\t      buffer$$1[index++] = constants.BSON_DATA_INT; // Number of written bytes\n\n\t      var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t      index = index + numberOfWrittenBytes;\n\t      buffer$$1[index++] = 0; // Write the int value\n\n\t      buffer$$1[index++] = value & 0xff;\n\t      buffer$$1[index++] = value >> 8 & 0xff;\n\t      buffer$$1[index++] = value >> 16 & 0xff;\n\t      buffer$$1[index++] = value >> 24 & 0xff;\n\t    } else if (value >= constants.JS_INT_MIN && value <= constants.JS_INT_MAX) {\n\t      // Encode as double\n\t      buffer$$1[index++] = constants.BSON_DATA_NUMBER; // Number of written bytes\n\n\t      var _numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t      index = index + _numberOfWrittenBytes;\n\t      buffer$$1[index++] = 0; // Write float\n\n\t      writeIEEE754$1(buffer$$1, value, index, 'little', 52, 8); // Ajust index\n\n\t      index = index + 8;\n\t    } else {\n\t      // Set long type\n\t      buffer$$1[index++] = constants.BSON_DATA_LONG; // Number of written bytes\n\n\t      var _numberOfWrittenBytes2 = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t      index = index + _numberOfWrittenBytes2;\n\t      buffer$$1[index++] = 0;\n\t      var longVal = long_1.fromNumber(value);\n\t      var lowBits = longVal.getLowBits();\n\t      var highBits = longVal.getHighBits(); // Encode low bits\n\n\t      buffer$$1[index++] = lowBits & 0xff;\n\t      buffer$$1[index++] = lowBits >> 8 & 0xff;\n\t      buffer$$1[index++] = lowBits >> 16 & 0xff;\n\t      buffer$$1[index++] = lowBits >> 24 & 0xff; // Encode high bits\n\n\t      buffer$$1[index++] = highBits & 0xff;\n\t      buffer$$1[index++] = highBits >> 8 & 0xff;\n\t      buffer$$1[index++] = highBits >> 16 & 0xff;\n\t      buffer$$1[index++] = highBits >> 24 & 0xff;\n\t    }\n\t  } else {\n\t    // Encode as double\n\t    buffer$$1[index++] = constants.BSON_DATA_NUMBER; // Number of written bytes\n\n\t    var _numberOfWrittenBytes3 = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t    index = index + _numberOfWrittenBytes3;\n\t    buffer$$1[index++] = 0; // Write float\n\n\t    writeIEEE754$1(buffer$$1, value, index, 'little', 52, 8); // Ajust index\n\n\t    index = index + 8;\n\t  }\n\n\t  return index;\n\t}\n\n\tfunction serializeNull(buffer$$1, key, value, index, isArray) {\n\t  // Set long type\n\t  buffer$$1[index++] = constants.BSON_DATA_NULL; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeBoolean(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_BOOLEAN; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Encode the boolean value\n\n\t  buffer$$1[index++] = value ? 1 : 0;\n\t  return index;\n\t}\n\n\tfunction serializeDate(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_DATE; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the date\n\n\t  var dateInMilis = long_1.fromNumber(value.getTime());\n\t  var lowBits = dateInMilis.getLowBits();\n\t  var highBits = dateInMilis.getHighBits(); // Encode low bits\n\n\t  buffer$$1[index++] = lowBits & 0xff;\n\t  buffer$$1[index++] = lowBits >> 8 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 16 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = highBits & 0xff;\n\t  buffer$$1[index++] = highBits >> 8 & 0xff;\n\t  buffer$$1[index++] = highBits >> 16 & 0xff;\n\t  buffer$$1[index++] = highBits >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tfunction serializeRegExp(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_REGEXP; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\n\t  if (value.source && value.source.match(regexp$1) != null) {\n\t    throw Error('value ' + value.source + ' must not contain null bytes');\n\t  } // Adjust the index\n\n\n\t  index = index + buffer$$1.write(value.source, index, 'utf8'); // Write zero\n\n\t  buffer$$1[index++] = 0x00; // Write the parameters\n\n\t  if (value.ignoreCase) buffer$$1[index++] = 0x69; // i\n\n\t  if (value.global) buffer$$1[index++] = 0x73; // s\n\n\t  if (value.multiline) buffer$$1[index++] = 0x6d; // m\n\t  // Add ending zero\n\n\t  buffer$$1[index++] = 0x00;\n\t  return index;\n\t}\n\n\tfunction serializeBSONRegExp(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_REGEXP; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Check the pattern for 0 bytes\n\n\t  if (value.pattern.match(regexp$1) != null) {\n\t    // The BSON spec doesn't allow keys with null bytes because keys are\n\t    // null-terminated.\n\t    throw Error('pattern ' + value.pattern + ' must not contain null bytes');\n\t  } // Adjust the index\n\n\n\t  index = index + buffer$$1.write(value.pattern, index, 'utf8'); // Write zero\n\n\t  buffer$$1[index++] = 0x00; // Write the options\n\n\t  index = index + buffer$$1.write(value.options.split('').sort().join(''), index, 'utf8'); // Add ending zero\n\n\t  buffer$$1[index++] = 0x00;\n\t  return index;\n\t}\n\n\tfunction serializeMinMax(buffer$$1, key, value, index, isArray) {\n\t  // Write the type of either min or max key\n\t  if (value === null) {\n\t    buffer$$1[index++] = constants.BSON_DATA_NULL;\n\t  } else if (value._bsontype === 'MinKey') {\n\t    buffer$$1[index++] = constants.BSON_DATA_MIN_KEY;\n\t  } else {\n\t    buffer$$1[index++] = constants.BSON_DATA_MAX_KEY;\n\t  } // Number of written bytes\n\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeObjectId(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_OID; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the objectId into the shared buffer\n\n\t  if (typeof value.id === 'string') {\n\t    buffer$$1.write(value.id, index, 'binary');\n\t  } else if (value.id && value.id.copy) {\n\t    value.id.copy(buffer$$1, index, 0, 12);\n\t  } else {\n\t    throw new TypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');\n\t  } // Ajust index\n\n\n\t  return index + 12;\n\t}\n\n\tfunction serializeBuffer(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_BINARY; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Get size of the buffer (current write point)\n\n\t  var size = value.length; // Write the size of the string to buffer\n\n\t  buffer$$1[index++] = size & 0xff;\n\t  buffer$$1[index++] = size >> 8 & 0xff;\n\t  buffer$$1[index++] = size >> 16 & 0xff;\n\t  buffer$$1[index++] = size >> 24 & 0xff; // Write the default subtype\n\n\t  buffer$$1[index++] = constants.BSON_BINARY_SUBTYPE_DEFAULT; // Copy the content form the binary field to the buffer\n\n\t  value.copy(buffer$$1, index, 0, size); // Adjust the index\n\n\t  index = index + size;\n\t  return index;\n\t}\n\n\tfunction serializeObject(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, isArray, path) {\n\t  for (var i = 0; i < path.length; i++) {\n\t    if (path[i] === value) throw new Error('cyclic dependency detected');\n\t  } // Push value to stack\n\n\n\t  path.push(value); // Write the type\n\n\t  buffer$$1[index++] = Array.isArray(value) ? constants.BSON_DATA_ARRAY : constants.BSON_DATA_OBJECT; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  var endIndex = serializeInto(buffer$$1, value, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined, path); // Pop stack\n\n\t  path.pop();\n\t  return endIndex;\n\t}\n\n\tfunction serializeDecimal128(buffer$$1, key, value, index, isArray) {\n\t  buffer$$1[index++] = constants.BSON_DATA_DECIMAL128; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the data from the value\n\n\t  value.bytes.copy(buffer$$1, index, 0, 16);\n\t  return index + 16;\n\t}\n\n\tfunction serializeLong(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = value._bsontype === 'Long' ? constants.BSON_DATA_LONG : constants.BSON_DATA_TIMESTAMP; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the date\n\n\t  var lowBits = value.getLowBits();\n\t  var highBits = value.getHighBits(); // Encode low bits\n\n\t  buffer$$1[index++] = lowBits & 0xff;\n\t  buffer$$1[index++] = lowBits >> 8 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 16 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = highBits & 0xff;\n\t  buffer$$1[index++] = highBits >> 8 & 0xff;\n\t  buffer$$1[index++] = highBits >> 16 & 0xff;\n\t  buffer$$1[index++] = highBits >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tfunction serializeInt32(buffer$$1, key, value, index, isArray) {\n\t  // Set int type 32 bits or less\n\t  buffer$$1[index++] = constants.BSON_DATA_INT; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the int value\n\n\t  buffer$$1[index++] = value & 0xff;\n\t  buffer$$1[index++] = value >> 8 & 0xff;\n\t  buffer$$1[index++] = value >> 16 & 0xff;\n\t  buffer$$1[index++] = value >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tfunction serializeDouble(buffer$$1, key, value, index, isArray) {\n\t  // Encode as double\n\t  buffer$$1[index++] = constants.BSON_DATA_NUMBER; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write float\n\n\t  writeIEEE754$1(buffer$$1, value.value, index, 'little', 52, 8); // Adjust index\n\n\t  index = index + 8;\n\t  return index;\n\t}\n\n\tfunction serializeFunction(buffer$$1, key, value, index, checkKeys, depth, isArray) {\n\t  buffer$$1[index++] = constants.BSON_DATA_CODE; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Function string\n\n\t  var functionString = normalizedFunctionString$1(value); // Write the string\n\n\t  var size = buffer$$1.write(functionString, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t  buffer$$1[index] = size & 0xff;\n\t  buffer$$1[index + 1] = size >> 8 & 0xff;\n\t  buffer$$1[index + 2] = size >> 16 & 0xff;\n\t  buffer$$1[index + 3] = size >> 24 & 0xff; // Update index\n\n\t  index = index + 4 + size - 1; // Write zero\n\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeCode(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, isArray) {\n\t  if (value.scope && _typeof$3(value.scope) === 'object') {\n\t    // Write the type\n\t    buffer$$1[index++] = constants.BSON_DATA_CODE_W_SCOPE; // Number of written bytes\n\n\t    var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t    index = index + numberOfWrittenBytes;\n\t    buffer$$1[index++] = 0; // Starting index\n\n\t    var startIndex = index; // Serialize the function\n\t    // Get the function string\n\n\t    var functionString = typeof value.code === 'string' ? value.code : value.code.toString(); // Index adjustment\n\n\t    index = index + 4; // Write string into buffer\n\n\t    var codeSize = buffer$$1.write(functionString, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t    buffer$$1[index] = codeSize & 0xff;\n\t    buffer$$1[index + 1] = codeSize >> 8 & 0xff;\n\t    buffer$$1[index + 2] = codeSize >> 16 & 0xff;\n\t    buffer$$1[index + 3] = codeSize >> 24 & 0xff; // Write end 0\n\n\t    buffer$$1[index + 4 + codeSize - 1] = 0; // Write the\n\n\t    index = index + codeSize + 4; //\n\t    // Serialize the scope value\n\n\t    var endIndex = serializeInto(buffer$$1, value.scope, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined);\n\t    index = endIndex - 1; // Writ the total\n\n\t    var totalSize = endIndex - startIndex; // Write the total size of the object\n\n\t    buffer$$1[startIndex++] = totalSize & 0xff;\n\t    buffer$$1[startIndex++] = totalSize >> 8 & 0xff;\n\t    buffer$$1[startIndex++] = totalSize >> 16 & 0xff;\n\t    buffer$$1[startIndex++] = totalSize >> 24 & 0xff; // Write trailing zero\n\n\t    buffer$$1[index++] = 0;\n\t  } else {\n\t    buffer$$1[index++] = constants.BSON_DATA_CODE; // Number of written bytes\n\n\t    var _numberOfWrittenBytes4 = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t    index = index + _numberOfWrittenBytes4;\n\t    buffer$$1[index++] = 0; // Function string\n\n\t    var _functionString = value.code.toString(); // Write the string\n\n\n\t    var size = buffer$$1.write(_functionString, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t    buffer$$1[index] = size & 0xff;\n\t    buffer$$1[index + 1] = size >> 8 & 0xff;\n\t    buffer$$1[index + 2] = size >> 16 & 0xff;\n\t    buffer$$1[index + 3] = size >> 24 & 0xff; // Update index\n\n\t    index = index + 4 + size - 1; // Write zero\n\n\t    buffer$$1[index++] = 0;\n\t  }\n\n\t  return index;\n\t}\n\n\tfunction serializeBinary(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_BINARY; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Extract the buffer\n\n\t  var data = value.value(true); // Calculate size\n\n\t  var size = value.position; // Add the deprecated 02 type 4 bytes of size to total\n\n\t  if (value.sub_type === binary.SUBTYPE_BYTE_ARRAY) size = size + 4; // Write the size of the string to buffer\n\n\t  buffer$$1[index++] = size & 0xff;\n\t  buffer$$1[index++] = size >> 8 & 0xff;\n\t  buffer$$1[index++] = size >> 16 & 0xff;\n\t  buffer$$1[index++] = size >> 24 & 0xff; // Write the subtype to the buffer\n\n\t  buffer$$1[index++] = value.sub_type; // If we have binary type 2 the 4 first bytes are the size\n\n\t  if (value.sub_type === binary.SUBTYPE_BYTE_ARRAY) {\n\t    size = size - 4;\n\t    buffer$$1[index++] = size & 0xff;\n\t    buffer$$1[index++] = size >> 8 & 0xff;\n\t    buffer$$1[index++] = size >> 16 & 0xff;\n\t    buffer$$1[index++] = size >> 24 & 0xff;\n\t  } // Write the data to the object\n\n\n\t  data.copy(buffer$$1, index, 0, value.position); // Adjust the index\n\n\t  index = index + value.position;\n\t  return index;\n\t}\n\n\tfunction serializeSymbol(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_SYMBOL; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the string\n\n\t  var size = buffer$$1.write(value.value, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t  buffer$$1[index] = size & 0xff;\n\t  buffer$$1[index + 1] = size >> 8 & 0xff;\n\t  buffer$$1[index + 2] = size >> 16 & 0xff;\n\t  buffer$$1[index + 3] = size >> 24 & 0xff; // Update index\n\n\t  index = index + 4 + size - 1; // Write zero\n\n\t  buffer$$1[index++] = 0x00;\n\t  return index;\n\t}\n\n\tfunction serializeDBRef(buffer$$1, key, value, index, depth, serializeFunctions, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_OBJECT; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  var startIndex = index;\n\t  var endIndex;\n\t  var output = {\n\t    $ref: value.collection || value.namespace,\n\t    // \"namespace\" was what library 1.x called \"collection\"\n\t    $id: value.oid\n\t  };\n\t  if (value.db != null) output.$db = value.db;\n\t  output = Object.assign(output, value.fields);\n\t  endIndex = serializeInto(buffer$$1, output, false, index, depth + 1, serializeFunctions); // Calculate object size\n\n\t  var size = endIndex - startIndex; // Write the size\n\n\t  buffer$$1[startIndex++] = size & 0xff;\n\t  buffer$$1[startIndex++] = size >> 8 & 0xff;\n\t  buffer$$1[startIndex++] = size >> 16 & 0xff;\n\t  buffer$$1[startIndex++] = size >> 24 & 0xff; // Set index\n\n\t  return endIndex;\n\t}\n\n\tfunction serializeInto(buffer$$1, object, checkKeys, startingIndex, depth, serializeFunctions, ignoreUndefined, path) {\n\t  startingIndex = startingIndex || 0;\n\t  path = path || []; // Push the object to the path\n\n\t  path.push(object); // Start place to serialize into\n\n\t  var index = startingIndex + 4; // Special case isArray\n\n\t  if (Array.isArray(object)) {\n\t    // Get object keys\n\t    for (var i = 0; i < object.length; i++) {\n\t      var key = '' + i;\n\t      var value = object[i]; // Is there an override value\n\n\t      if (value && value.toBSON) {\n\t        if (typeof value.toBSON !== 'function') throw new TypeError('toBSON is not a function');\n\t        value = value.toBSON();\n\t      }\n\n\t      var type = _typeof$3(value);\n\n\t      if (type === 'string') {\n\t        index = serializeString(buffer$$1, key, value, index, true);\n\t      } else if (type === 'number') {\n\t        index = serializeNumber(buffer$$1, key, value, index, true);\n\t      } else if (type === 'boolean') {\n\t        index = serializeBoolean(buffer$$1, key, value, index, true);\n\t      } else if (value instanceof Date || isDate$1(value)) {\n\t        index = serializeDate(buffer$$1, key, value, index, true);\n\t      } else if (value === undefined) {\n\t        index = serializeNull(buffer$$1, key, value, index, true);\n\t      } else if (value === null) {\n\t        index = serializeNull(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'ObjectId' || value['_bsontype'] === 'ObjectID') {\n\t        index = serializeObjectId(buffer$$1, key, value, index, true);\n\t      } else if (Buffer$5.isBuffer(value)) {\n\t        index = serializeBuffer(buffer$$1, key, value, index, true);\n\t      } else if (value instanceof RegExp || isRegExp$1(value)) {\n\t        index = serializeRegExp(buffer$$1, key, value, index, true);\n\t      } else if (type === 'object' && value['_bsontype'] == null) {\n\t        index = serializeObject(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, true, path);\n\t      } else if (type === 'object' && value['_bsontype'] === 'Decimal128') {\n\t        index = serializeDecimal128(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Long' || value['_bsontype'] === 'Timestamp') {\n\t        index = serializeLong(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Double') {\n\t        index = serializeDouble(buffer$$1, key, value, index, true);\n\t      } else if (typeof value === 'function' && serializeFunctions) {\n\t        index = serializeFunction(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, true);\n\t      } else if (value['_bsontype'] === 'Code') {\n\t        index = serializeCode(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, true);\n\t      } else if (value['_bsontype'] === 'Binary') {\n\t        index = serializeBinary(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Symbol') {\n\t        index = serializeSymbol(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'DBRef') {\n\t        index = serializeDBRef(buffer$$1, key, value, index, depth, serializeFunctions, true);\n\t      } else if (value['_bsontype'] === 'BSONRegExp') {\n\t        index = serializeBSONRegExp(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Int32') {\n\t        index = serializeInt32(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {\n\t        index = serializeMinMax(buffer$$1, key, value, index, true);\n\t      } else if (typeof value['_bsontype'] !== 'undefined') {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);\n\t      }\n\t    }\n\t  } else if (object instanceof map) {\n\t    var iterator = object.entries();\n\t    var done = false;\n\n\t    while (!done) {\n\t      // Unpack the next entry\n\t      var entry = iterator.next();\n\t      done = entry.done; // Are we done, then skip and terminate\n\n\t      if (done) continue; // Get the entry values\n\n\t      var _key = entry.value[0];\n\t      var _value = entry.value[1]; // Check the type of the value\n\n\t      var _type = _typeof$3(_value); // Check the key and throw error if it's illegal\n\n\n\t      if (typeof _key === 'string' && !ignoreKeys.has(_key)) {\n\t        if (_key.match(regexp$1) != null) {\n\t          // The BSON spec doesn't allow keys with null bytes because keys are\n\t          // null-terminated.\n\t          throw Error('key ' + _key + ' must not contain null bytes');\n\t        }\n\n\t        if (checkKeys) {\n\t          if ('$' === _key[0]) {\n\t            throw Error('key ' + _key + \" must not start with '$'\");\n\t          } else if (~_key.indexOf('.')) {\n\t            throw Error('key ' + _key + \" must not contain '.'\");\n\t          }\n\t        }\n\t      }\n\n\t      if (_type === 'string') {\n\t        index = serializeString(buffer$$1, _key, _value, index);\n\t      } else if (_type === 'number') {\n\t        index = serializeNumber(buffer$$1, _key, _value, index);\n\t      } else if (_type === 'boolean') {\n\t        index = serializeBoolean(buffer$$1, _key, _value, index);\n\t      } else if (_value instanceof Date || isDate$1(_value)) {\n\t        index = serializeDate(buffer$$1, _key, _value, index);\n\t      } else if (_value === null || _value === undefined && ignoreUndefined === false) {\n\t        index = serializeNull(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'ObjectId' || _value['_bsontype'] === 'ObjectID') {\n\t        index = serializeObjectId(buffer$$1, _key, _value, index);\n\t      } else if (Buffer$5.isBuffer(_value)) {\n\t        index = serializeBuffer(buffer$$1, _key, _value, index);\n\t      } else if (_value instanceof RegExp || isRegExp$1(_value)) {\n\t        index = serializeRegExp(buffer$$1, _key, _value, index);\n\t      } else if (_type === 'object' && _value['_bsontype'] == null) {\n\t        index = serializeObject(buffer$$1, _key, _value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, false, path);\n\t      } else if (_type === 'object' && _value['_bsontype'] === 'Decimal128') {\n\t        index = serializeDecimal128(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Long' || _value['_bsontype'] === 'Timestamp') {\n\t        index = serializeLong(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Double') {\n\t        index = serializeDouble(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Code') {\n\t        index = serializeCode(buffer$$1, _key, _value, index, checkKeys, depth, serializeFunctions, ignoreUndefined);\n\t      } else if (typeof _value === 'function' && serializeFunctions) {\n\t        index = serializeFunction(buffer$$1, _key, _value, index, checkKeys, depth, serializeFunctions);\n\t      } else if (_value['_bsontype'] === 'Binary') {\n\t        index = serializeBinary(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Symbol') {\n\t        index = serializeSymbol(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'DBRef') {\n\t        index = serializeDBRef(buffer$$1, _key, _value, index, depth, serializeFunctions);\n\t      } else if (_value['_bsontype'] === 'BSONRegExp') {\n\t        index = serializeBSONRegExp(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Int32') {\n\t        index = serializeInt32(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'MinKey' || _value['_bsontype'] === 'MaxKey') {\n\t        index = serializeMinMax(buffer$$1, _key, _value, index);\n\t      } else if (typeof _value['_bsontype'] !== 'undefined') {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + _value['_bsontype']);\n\t      }\n\t    }\n\t  } else {\n\t    // Did we provide a custom serialization method\n\t    if (object.toBSON) {\n\t      if (typeof object.toBSON !== 'function') throw new TypeError('toBSON is not a function');\n\t      object = object.toBSON();\n\t      if (object != null && _typeof$3(object) !== 'object') throw new TypeError('toBSON function did not return an object');\n\t    } // Iterate over all the keys\n\n\n\t    for (var _key2 in object) {\n\t      var _value2 = object[_key2]; // Is there an override value\n\n\t      if (_value2 && _value2.toBSON) {\n\t        if (typeof _value2.toBSON !== 'function') throw new TypeError('toBSON is not a function');\n\t        _value2 = _value2.toBSON();\n\t      } // Check the type of the value\n\n\n\t      var _type2 = _typeof$3(_value2); // Check the key and throw error if it's illegal\n\n\n\t      if (typeof _key2 === 'string' && !ignoreKeys.has(_key2)) {\n\t        if (_key2.match(regexp$1) != null) {\n\t          // The BSON spec doesn't allow keys with null bytes because keys are\n\t          // null-terminated.\n\t          throw Error('key ' + _key2 + ' must not contain null bytes');\n\t        }\n\n\t        if (checkKeys) {\n\t          if ('$' === _key2[0]) {\n\t            throw Error('key ' + _key2 + \" must not start with '$'\");\n\t          } else if (~_key2.indexOf('.')) {\n\t            throw Error('key ' + _key2 + \" must not contain '.'\");\n\t          }\n\t        }\n\t      }\n\n\t      if (_type2 === 'string') {\n\t        index = serializeString(buffer$$1, _key2, _value2, index);\n\t      } else if (_type2 === 'number') {\n\t        index = serializeNumber(buffer$$1, _key2, _value2, index);\n\t      } else if (_type2 === 'boolean') {\n\t        index = serializeBoolean(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 instanceof Date || isDate$1(_value2)) {\n\t        index = serializeDate(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 === undefined) {\n\t        if (ignoreUndefined === false) index = serializeNull(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 === null) {\n\t        index = serializeNull(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'ObjectId' || _value2['_bsontype'] === 'ObjectID') {\n\t        index = serializeObjectId(buffer$$1, _key2, _value2, index);\n\t      } else if (Buffer$5.isBuffer(_value2)) {\n\t        index = serializeBuffer(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 instanceof RegExp || isRegExp$1(_value2)) {\n\t        index = serializeRegExp(buffer$$1, _key2, _value2, index);\n\t      } else if (_type2 === 'object' && _value2['_bsontype'] == null) {\n\t        index = serializeObject(buffer$$1, _key2, _value2, index, checkKeys, depth, serializeFunctions, ignoreUndefined, false, path);\n\t      } else if (_type2 === 'object' && _value2['_bsontype'] === 'Decimal128') {\n\t        index = serializeDecimal128(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Long' || _value2['_bsontype'] === 'Timestamp') {\n\t        index = serializeLong(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Double') {\n\t        index = serializeDouble(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Code') {\n\t        index = serializeCode(buffer$$1, _key2, _value2, index, checkKeys, depth, serializeFunctions, ignoreUndefined);\n\t      } else if (typeof _value2 === 'function' && serializeFunctions) {\n\t        index = serializeFunction(buffer$$1, _key2, _value2, index, checkKeys, depth, serializeFunctions);\n\t      } else if (_value2['_bsontype'] === 'Binary') {\n\t        index = serializeBinary(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Symbol') {\n\t        index = serializeSymbol(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'DBRef') {\n\t        index = serializeDBRef(buffer$$1, _key2, _value2, index, depth, serializeFunctions);\n\t      } else if (_value2['_bsontype'] === 'BSONRegExp') {\n\t        index = serializeBSONRegExp(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Int32') {\n\t        index = serializeInt32(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'MinKey' || _value2['_bsontype'] === 'MaxKey') {\n\t        index = serializeMinMax(buffer$$1, _key2, _value2, index);\n\t      } else if (typeof _value2['_bsontype'] !== 'undefined') {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + _value2['_bsontype']);\n\t      }\n\t    }\n\t  } // Remove the path\n\n\n\t  path.pop(); // Final padding byte for object\n\n\t  buffer$$1[index++] = 0x00; // Final size\n\n\t  var size = index - startingIndex; // Write the size of the object\n\n\t  buffer$$1[startingIndex++] = size & 0xff;\n\t  buffer$$1[startingIndex++] = size >> 8 & 0xff;\n\t  buffer$$1[startingIndex++] = size >> 16 & 0xff;\n\t  buffer$$1[startingIndex++] = size >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tvar serializer = serializeInto;\n\n\tfunction _typeof$4(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$4 = function _typeof(obj) { return typeof obj; }; } else { _typeof$4 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$4(obj); }\n\n\tvar Buffer$6 = buffer.Buffer;\n\tvar normalizedFunctionString$2 = utils.normalizedFunctionString; // To ensure that 0.4 of node works correctly\n\n\tfunction isDate$2(d) {\n\t  return _typeof$4(d) === 'object' && Object.prototype.toString.call(d) === '[object Date]';\n\t}\n\n\tfunction calculateObjectSize(object, serializeFunctions, ignoreUndefined) {\n\t  var totalLength = 4 + 1;\n\n\t  if (Array.isArray(object)) {\n\t    for (var i = 0; i < object.length; i++) {\n\t      totalLength += calculateElement(i.toString(), object[i], serializeFunctions, true, ignoreUndefined);\n\t    }\n\t  } else {\n\t    // If we have toBSON defined, override the current object\n\t    if (object.toBSON) {\n\t      object = object.toBSON();\n\t    } // Calculate size\n\n\n\t    for (var key in object) {\n\t      totalLength += calculateElement(key, object[key], serializeFunctions, false, ignoreUndefined);\n\t    }\n\t  }\n\n\t  return totalLength;\n\t}\n\t/**\n\t * @ignore\n\t * @api private\n\t */\n\n\n\tfunction calculateElement(name, value, serializeFunctions, isArray, ignoreUndefined) {\n\t  // If we have toBSON defined, override the current object\n\t  if (value && value.toBSON) {\n\t    value = value.toBSON();\n\t  }\n\n\t  switch (_typeof$4(value)) {\n\t    case 'string':\n\t      return 1 + Buffer$6.byteLength(name, 'utf8') + 1 + 4 + Buffer$6.byteLength(value, 'utf8') + 1;\n\n\t    case 'number':\n\t      if (Math.floor(value) === value && value >= constants.JS_INT_MIN && value <= constants.JS_INT_MAX) {\n\t        if (value >= constants.BSON_INT32_MIN && value <= constants.BSON_INT32_MAX) {\n\t          // 32 bit\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (4 + 1);\n\t        } else {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t        }\n\t      } else {\n\t        // 64 bit\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t      }\n\n\t    case 'undefined':\n\t      if (isArray || !ignoreUndefined) return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1;\n\t      return 0;\n\n\t    case 'boolean':\n\t      return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (1 + 1);\n\n\t    case 'object':\n\t      if (value == null || value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1;\n\t      } else if (value['_bsontype'] === 'ObjectId' || value['_bsontype'] === 'ObjectID') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (12 + 1);\n\t      } else if (value instanceof Date || isDate$2(value)) {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t      } else if (typeof Buffer$6 !== 'undefined' && Buffer$6.isBuffer(value)) {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (1 + 4 + 1) + value.length;\n\t      } else if (value['_bsontype'] === 'Long' || value['_bsontype'] === 'Double' || value['_bsontype'] === 'Timestamp') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t      } else if (value['_bsontype'] === 'Decimal128') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (16 + 1);\n\t      } else if (value['_bsontype'] === 'Code') {\n\t        // Calculate size depending on the availability of a scope\n\t        if (value.scope != null && Object.keys(value.scope).length > 0) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + 4 + Buffer$6.byteLength(value.code.toString(), 'utf8') + 1 + calculateObjectSize(value.scope, serializeFunctions, ignoreUndefined);\n\t        } else {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + Buffer$6.byteLength(value.code.toString(), 'utf8') + 1;\n\t        }\n\t      } else if (value['_bsontype'] === 'Binary') {\n\t        // Check what kind of subtype we have\n\t        if (value.sub_type === binary.SUBTYPE_BYTE_ARRAY) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1 + 4);\n\t        } else {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1);\n\t        }\n\t      } else if (value['_bsontype'] === 'Symbol') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + Buffer$6.byteLength(value.value, 'utf8') + 4 + 1 + 1;\n\t      } else if (value['_bsontype'] === 'DBRef') {\n\t        // Set up correct object for serialization\n\t        var ordered_values = Object.assign({\n\t          $ref: value.collection,\n\t          $id: value.oid\n\t        }, value.fields); // Add db reference if it exists\n\n\t        if (value.db != null) {\n\t          ordered_values['$db'] = value.db;\n\t        }\n\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + calculateObjectSize(ordered_values, serializeFunctions, ignoreUndefined);\n\t      } else if (value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + Buffer$6.byteLength(value.source, 'utf8') + 1 + (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) + 1;\n\t      } else if (value['_bsontype'] === 'BSONRegExp') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + Buffer$6.byteLength(value.pattern, 'utf8') + 1 + Buffer$6.byteLength(value.options, 'utf8') + 1;\n\t      } else {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + calculateObjectSize(value, serializeFunctions, ignoreUndefined) + 1;\n\t      }\n\n\t    case 'function':\n\t      // WTF for 0.4.X where typeof /someregexp/ === 'function'\n\t      if (value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]' || String.call(value) === '[object RegExp]') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + Buffer$6.byteLength(value.source, 'utf8') + 1 + (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) + 1;\n\t      } else {\n\t        if (serializeFunctions && value.scope != null && Object.keys(value.scope).length > 0) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + 4 + Buffer$6.byteLength(normalizedFunctionString$2(value), 'utf8') + 1 + calculateObjectSize(value.scope, serializeFunctions, ignoreUndefined);\n\t        } else if (serializeFunctions) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + Buffer$6.byteLength(normalizedFunctionString$2(value), 'utf8') + 1;\n\t        }\n\t      }\n\n\t  }\n\n\t  return 0;\n\t}\n\n\tvar calculate_size = calculateObjectSize;\n\n\tvar Buffer$7 = buffer.Buffer;\n\t/**\n\t * Makes sure that, if a Uint8Array is passed in, it is wrapped in a Buffer.\n\t *\n\t * @param {Buffer|Uint8Array} potentialBuffer The potential buffer\n\t * @returns {Buffer} the input if potentialBuffer is a buffer, or a buffer that\n\t * wraps a passed in Uint8Array\n\t * @throws {TypeError} If anything other than a Buffer or Uint8Array is passed in\n\t */\n\n\tvar ensure_buffer = function ensureBuffer(potentialBuffer) {\n\t  if (potentialBuffer instanceof Buffer$7) {\n\t    return potentialBuffer;\n\t  }\n\n\t  if (potentialBuffer instanceof Uint8Array) {\n\t    return Buffer$7.from(potentialBuffer.buffer);\n\t  }\n\n\t  throw new TypeError('Must use either Buffer or Uint8Array');\n\t};\n\n\tvar Buffer$8 = buffer.Buffer; // Parts of the parser\n\n\t/**\n\t * @ignore\n\t */\n\t// Default Max Size\n\n\tvar MAXSIZE = 1024 * 1024 * 17; // Current Internal Temporary Serialization Buffer\n\n\tvar buffer$1 = Buffer$8.alloc(MAXSIZE);\n\t/**\n\t * Sets the size of the internal serialization buffer.\n\t *\n\t * @method\n\t * @param {number} size The desired size for the internal serialization buffer\n\t */\n\n\tfunction setInternalBufferSize(size) {\n\t  // Resize the internal serialization buffer if needed\n\t  if (buffer$1.length < size) {\n\t    buffer$1 = Buffer$8.alloc(size);\n\t  }\n\t}\n\t/**\n\t * Serialize a Javascript object.\n\t *\n\t * @param {Object} object the Javascript object to serialize.\n\t * @param {Boolean} [options.checkKeys] the serializer will check if keys are valid.\n\t * @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.\n\t * @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.\n\t * @return {Buffer} returns the Buffer object containing the serialized object.\n\t */\n\n\n\tfunction serialize$1(object, options) {\n\t  options = options || {}; // Unpack the options\n\n\t  var checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;\n\t  var serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n\t  var ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n\t  var minInternalBufferSize = typeof options.minInternalBufferSize === 'number' ? options.minInternalBufferSize : MAXSIZE; // Resize the internal serialization buffer if needed\n\n\t  if (buffer$1.length < minInternalBufferSize) {\n\t    buffer$1 = Buffer$8.alloc(minInternalBufferSize);\n\t  } // Attempt to serialize\n\n\n\t  var serializationIndex = serializer(buffer$1, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined, []); // Create the final buffer\n\n\t  var finishedBuffer = Buffer$8.alloc(serializationIndex); // Copy into the finished buffer\n\n\t  buffer$1.copy(finishedBuffer, 0, 0, finishedBuffer.length); // Return the buffer\n\n\t  return finishedBuffer;\n\t}\n\t/**\n\t * Serialize a Javascript object using a predefined Buffer and index into the buffer, useful when pre-allocating the space for serialization.\n\t *\n\t * @param {Object} object the Javascript object to serialize.\n\t * @param {Buffer} buffer the Buffer you pre-allocated to store the serialized BSON object.\n\t * @param {Boolean} [options.checkKeys] the serializer will check if keys are valid.\n\t * @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.\n\t * @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.\n\t * @param {Number} [options.index] the index in the buffer where we wish to start serializing into.\n\t * @return {Number} returns the index pointing to the last written byte in the buffer.\n\t */\n\n\n\tfunction serializeWithBufferAndIndex(object, finalBuffer, options) {\n\t  options = options || {}; // Unpack the options\n\n\t  var checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;\n\t  var serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n\t  var ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n\t  var startIndex = typeof options.index === 'number' ? options.index : 0; // Attempt to serialize\n\n\t  var serializationIndex = serializer(buffer$1, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined);\n\t  buffer$1.copy(finalBuffer, startIndex, 0, serializationIndex); // Return the index\n\n\t  return startIndex + serializationIndex - 1;\n\t}\n\t/**\n\t * Deserialize data as BSON.\n\t *\n\t * @param {Buffer} buffer the buffer containing the serialized set of BSON documents.\n\t * @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.\n\t * @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.\n\t * @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.\n\t * @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits\n\t * @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a node.js Buffer instance.\n\t * @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.\n\t * @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.\n\t * @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.\n\t * @param {boolean} [options.allowObjectSmallerThanBufferSize=false] allows the buffer to be larger than the parsed BSON object\n\t * @return {Object} returns the deserialized Javascript Object.\n\t */\n\n\n\tfunction deserialize$2(buffer$$1, options) {\n\t  buffer$$1 = ensure_buffer(buffer$$1);\n\t  return deserializer(buffer$$1, options);\n\t}\n\t/**\n\t * Calculate the bson size for a passed in Javascript object.\n\t *\n\t * @param {Object} object the Javascript object to calculate the BSON byte size for.\n\t * @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.\n\t * @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.\n\t * @return {Number} returns the number of bytes the BSON object will take up.\n\t */\n\n\n\tfunction calculateObjectSize$1(object, options) {\n\t  options = options || {};\n\t  var serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n\t  var ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n\t  return calculate_size(object, serializeFunctions, ignoreUndefined);\n\t}\n\t/**\n\t * Deserialize stream data as BSON documents.\n\t *\n\t * @param {Buffer} data the buffer containing the serialized set of BSON documents.\n\t * @param {Number} startIndex the start index in the data Buffer where the deserialization is to start.\n\t * @param {Number} numberOfDocuments number of documents to deserialize.\n\t * @param {Array} documents an array where to store the deserialized documents.\n\t * @param {Number} docStartIndex the index in the documents array from where to start inserting documents.\n\t * @param {Object} [options] additional options used for the deserialization.\n\t * @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.\n\t * @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.\n\t * @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.\n\t * @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits\n\t * @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a node.js Buffer instance.\n\t * @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.\n\t * @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.\n\t * @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.\n\t * @return {Number} returns the next index in the buffer after deserialization **x** numbers of documents.\n\t */\n\n\n\tfunction deserializeStream(data, startIndex, numberOfDocuments, documents, docStartIndex, options) {\n\t  options = Object.assign({\n\t    allowObjectSmallerThanBufferSize: true\n\t  }, options);\n\t  data = ensure_buffer(data);\n\t  var index = startIndex; // Loop over all documents\n\n\t  for (var i = 0; i < numberOfDocuments; i++) {\n\t    // Find size of the document\n\t    var size = data[index] | data[index + 1] << 8 | data[index + 2] << 16 | data[index + 3] << 24; // Update options with index\n\n\t    options.index = index; // Parse the document at this point\n\n\t    documents[docStartIndex + i] = deserializer(data, options); // Adjust index by the document size\n\n\t    index = index + size;\n\t  } // Return object containing end index of parsing and list of documents\n\n\n\t  return index;\n\t}\n\n\tvar bson = {\n\t  // constants\n\t  // NOTE: this is done this way because rollup can't resolve an `Object.assign`ed export\n\t  BSON_INT32_MAX: constants.BSON_INT32_MAX,\n\t  BSON_INT32_MIN: constants.BSON_INT32_MIN,\n\t  BSON_INT64_MAX: constants.BSON_INT64_MAX,\n\t  BSON_INT64_MIN: constants.BSON_INT64_MIN,\n\t  JS_INT_MAX: constants.JS_INT_MAX,\n\t  JS_INT_MIN: constants.JS_INT_MIN,\n\t  BSON_DATA_NUMBER: constants.BSON_DATA_NUMBER,\n\t  BSON_DATA_STRING: constants.BSON_DATA_STRING,\n\t  BSON_DATA_OBJECT: constants.BSON_DATA_OBJECT,\n\t  BSON_DATA_ARRAY: constants.BSON_DATA_ARRAY,\n\t  BSON_DATA_BINARY: constants.BSON_DATA_BINARY,\n\t  BSON_DATA_UNDEFINED: constants.BSON_DATA_UNDEFINED,\n\t  BSON_DATA_OID: constants.BSON_DATA_OID,\n\t  BSON_DATA_BOOLEAN: constants.BSON_DATA_BOOLEAN,\n\t  BSON_DATA_DATE: constants.BSON_DATA_DATE,\n\t  BSON_DATA_NULL: constants.BSON_DATA_NULL,\n\t  BSON_DATA_REGEXP: constants.BSON_DATA_REGEXP,\n\t  BSON_DATA_DBPOINTER: constants.BSON_DATA_DBPOINTER,\n\t  BSON_DATA_CODE: constants.BSON_DATA_CODE,\n\t  BSON_DATA_SYMBOL: constants.BSON_DATA_SYMBOL,\n\t  BSON_DATA_CODE_W_SCOPE: constants.BSON_DATA_CODE_W_SCOPE,\n\t  BSON_DATA_INT: constants.BSON_DATA_INT,\n\t  BSON_DATA_TIMESTAMP: constants.BSON_DATA_TIMESTAMP,\n\t  BSON_DATA_LONG: constants.BSON_DATA_LONG,\n\t  BSON_DATA_DECIMAL128: constants.BSON_DATA_DECIMAL128,\n\t  BSON_DATA_MIN_KEY: constants.BSON_DATA_MIN_KEY,\n\t  BSON_DATA_MAX_KEY: constants.BSON_DATA_MAX_KEY,\n\t  BSON_BINARY_SUBTYPE_DEFAULT: constants.BSON_BINARY_SUBTYPE_DEFAULT,\n\t  BSON_BINARY_SUBTYPE_FUNCTION: constants.BSON_BINARY_SUBTYPE_FUNCTION,\n\t  BSON_BINARY_SUBTYPE_BYTE_ARRAY: constants.BSON_BINARY_SUBTYPE_BYTE_ARRAY,\n\t  BSON_BINARY_SUBTYPE_UUID: constants.BSON_BINARY_SUBTYPE_UUID,\n\t  BSON_BINARY_SUBTYPE_MD5: constants.BSON_BINARY_SUBTYPE_MD5,\n\t  BSON_BINARY_SUBTYPE_USER_DEFINED: constants.BSON_BINARY_SUBTYPE_USER_DEFINED,\n\t  // wrapped types\n\t  Code: code,\n\t  Map: map,\n\t  BSONSymbol: symbol,\n\t  DBRef: db_ref,\n\t  Binary: binary,\n\t  ObjectId: objectid,\n\t  Long: long_1,\n\t  Timestamp: timestamp,\n\t  Double: double_1,\n\t  Int32: int_32,\n\t  MinKey: min_key,\n\t  MaxKey: max_key,\n\t  BSONRegExp: regexp,\n\t  Decimal128: decimal128,\n\t  // methods\n\t  serialize: serialize$1,\n\t  serializeWithBufferAndIndex: serializeWithBufferAndIndex,\n\t  deserialize: deserialize$2,\n\t  calculateObjectSize: calculateObjectSize$1,\n\t  deserializeStream: deserializeStream,\n\t  setInternalBufferSize: setInternalBufferSize,\n\t  // legacy support\n\t  ObjectID: objectid,\n\t  // Extended JSON\n\t  EJSON: extended_json\n\t};\n\tvar bson_1 = bson.BSON_INT32_MAX;\n\tvar bson_2 = bson.BSON_INT32_MIN;\n\tvar bson_3 = bson.BSON_INT64_MAX;\n\tvar bson_4 = bson.BSON_INT64_MIN;\n\tvar bson_5 = bson.JS_INT_MAX;\n\tvar bson_6 = bson.JS_INT_MIN;\n\tvar bson_7 = bson.BSON_DATA_NUMBER;\n\tvar bson_8 = bson.BSON_DATA_STRING;\n\tvar bson_9 = bson.BSON_DATA_OBJECT;\n\tvar bson_10 = bson.BSON_DATA_ARRAY;\n\tvar bson_11 = bson.BSON_DATA_BINARY;\n\tvar bson_12 = bson.BSON_DATA_UNDEFINED;\n\tvar bson_13 = bson.BSON_DATA_OID;\n\tvar bson_14 = bson.BSON_DATA_BOOLEAN;\n\tvar bson_15 = bson.BSON_DATA_DATE;\n\tvar bson_16 = bson.BSON_DATA_NULL;\n\tvar bson_17 = bson.BSON_DATA_REGEXP;\n\tvar bson_18 = bson.BSON_DATA_DBPOINTER;\n\tvar bson_19 = bson.BSON_DATA_CODE;\n\tvar bson_20 = bson.BSON_DATA_SYMBOL;\n\tvar bson_21 = bson.BSON_DATA_CODE_W_SCOPE;\n\tvar bson_22 = bson.BSON_DATA_INT;\n\tvar bson_23 = bson.BSON_DATA_TIMESTAMP;\n\tvar bson_24 = bson.BSON_DATA_LONG;\n\tvar bson_25 = bson.BSON_DATA_DECIMAL128;\n\tvar bson_26 = bson.BSON_DATA_MIN_KEY;\n\tvar bson_27 = bson.BSON_DATA_MAX_KEY;\n\tvar bson_28 = bson.BSON_BINARY_SUBTYPE_DEFAULT;\n\tvar bson_29 = bson.BSON_BINARY_SUBTYPE_FUNCTION;\n\tvar bson_30 = bson.BSON_BINARY_SUBTYPE_BYTE_ARRAY;\n\tvar bson_31 = bson.BSON_BINARY_SUBTYPE_UUID;\n\tvar bson_32 = bson.BSON_BINARY_SUBTYPE_MD5;\n\tvar bson_33 = bson.BSON_BINARY_SUBTYPE_USER_DEFINED;\n\tvar bson_34 = bson.Code;\n\tvar bson_35 = bson.BSONSymbol;\n\tvar bson_36 = bson.DBRef;\n\tvar bson_37 = bson.Binary;\n\tvar bson_38 = bson.ObjectId;\n\tvar bson_39 = bson.Long;\n\tvar bson_40 = bson.Timestamp;\n\tvar bson_41 = bson.Double;\n\tvar bson_42 = bson.Int32;\n\tvar bson_43 = bson.MinKey;\n\tvar bson_44 = bson.MaxKey;\n\tvar bson_45 = bson.BSONRegExp;\n\tvar bson_46 = bson.Decimal128;\n\tvar bson_47 = bson.serialize;\n\tvar bson_48 = bson.serializeWithBufferAndIndex;\n\tvar bson_49 = bson.deserialize;\n\tvar bson_50 = bson.calculateObjectSize;\n\tvar bson_51 = bson.deserializeStream;\n\tvar bson_52 = bson.setInternalBufferSize;\n\tvar bson_53 = bson.ObjectID;\n\tvar bson_54 = bson.EJSON;\n\n\texports.default = bson;\n\texports.BSON_INT32_MAX = bson_1;\n\texports.BSON_INT32_MIN = bson_2;\n\texports.BSON_INT64_MAX = bson_3;\n\texports.BSON_INT64_MIN = bson_4;\n\texports.JS_INT_MAX = bson_5;\n\texports.JS_INT_MIN = bson_6;\n\texports.BSON_DATA_NUMBER = bson_7;\n\texports.BSON_DATA_STRING = bson_8;\n\texports.BSON_DATA_OBJECT = bson_9;\n\texports.BSON_DATA_ARRAY = bson_10;\n\texports.BSON_DATA_BINARY = bson_11;\n\texports.BSON_DATA_UNDEFINED = bson_12;\n\texports.BSON_DATA_OID = bson_13;\n\texports.BSON_DATA_BOOLEAN = bson_14;\n\texports.BSON_DATA_DATE = bson_15;\n\texports.BSON_DATA_NULL = bson_16;\n\texports.BSON_DATA_REGEXP = bson_17;\n\texports.BSON_DATA_DBPOINTER = bson_18;\n\texports.BSON_DATA_CODE = bson_19;\n\texports.BSON_DATA_SYMBOL = bson_20;\n\texports.BSON_DATA_CODE_W_SCOPE = bson_21;\n\texports.BSON_DATA_INT = bson_22;\n\texports.BSON_DATA_TIMESTAMP = bson_23;\n\texports.BSON_DATA_LONG = bson_24;\n\texports.BSON_DATA_DECIMAL128 = bson_25;\n\texports.BSON_DATA_MIN_KEY = bson_26;\n\texports.BSON_DATA_MAX_KEY = bson_27;\n\texports.BSON_BINARY_SUBTYPE_DEFAULT = bson_28;\n\texports.BSON_BINARY_SUBTYPE_FUNCTION = bson_29;\n\texports.BSON_BINARY_SUBTYPE_BYTE_ARRAY = bson_30;\n\texports.BSON_BINARY_SUBTYPE_UUID = bson_31;\n\texports.BSON_BINARY_SUBTYPE_MD5 = bson_32;\n\texports.BSON_BINARY_SUBTYPE_USER_DEFINED = bson_33;\n\texports.Code = bson_34;\n\texports.BSONSymbol = bson_35;\n\texports.DBRef = bson_36;\n\texports.Binary = bson_37;\n\texports.ObjectId = bson_38;\n\texports.Long = bson_39;\n\texports.Timestamp = bson_40;\n\texports.Double = bson_41;\n\texports.Int32 = bson_42;\n\texports.MinKey = bson_43;\n\texports.MaxKey = bson_44;\n\texports.BSONRegExp = bson_45;\n\texports.Decimal128 = bson_46;\n\texports.serialize = bson_47;\n\texports.serializeWithBufferAndIndex = bson_48;\n\texports.deserialize = bson_49;\n\texports.calculateObjectSize = bson_50;\n\texports.deserializeStream = bson_51;\n\texports.setInternalBufferSize = bson_52;\n\texports.ObjectID = bson_53;\n\texports.EJSON = bson_54;\n\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(1).Buffer))\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports) {\n\nmodule.exports = Long;\r\n\r\n/**\r\n * wasm optimizations, to do native i64 multiplication and divide\r\n */\r\nvar wasm = null;\r\n\r\ntry {\r\n  wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([\r\n    0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11\r\n  ])), {}).exports;\r\n} catch (e) {\r\n  // no wasm support :(\r\n}\r\n\r\n/**\r\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\r\n *  See the from* functions below for more convenient ways of constructing Longs.\r\n * @exports Long\r\n * @class A Long class for representing a 64 bit two's-complement integer value.\r\n * @param {number} low The low (signed) 32 bits of the long\r\n * @param {number} high The high (signed) 32 bits of the long\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @constructor\r\n */\r\nfunction Long(low, high, unsigned) {\r\n\r\n    /**\r\n     * The low 32 bits as a signed value.\r\n     * @type {number}\r\n     */\r\n    this.low = low | 0;\r\n\r\n    /**\r\n     * The high 32 bits as a signed value.\r\n     * @type {number}\r\n     */\r\n    this.high = high | 0;\r\n\r\n    /**\r\n     * Whether unsigned or not.\r\n     * @type {boolean}\r\n     */\r\n    this.unsigned = !!unsigned;\r\n}\r\n\r\n// The internal representation of a long is the two given signed, 32-bit values.\r\n// We use 32-bit pieces because these are the size of integers on which\r\n// Javascript performs bit-operations.  For operations like addition and\r\n// multiplication, we split each number into 16 bit pieces, which can easily be\r\n// multiplied within Javascript's floating-point representation without overflow\r\n// or change in sign.\r\n//\r\n// In the algorithms below, we frequently reduce the negative case to the\r\n// positive case by negating the input(s) and then post-processing the result.\r\n// Note that we must ALWAYS check specially whether those values are MIN_VALUE\r\n// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\r\n// a positive number, it overflows back into a negative).  Not handling this\r\n// case would often result in infinite recursion.\r\n//\r\n// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\r\n// methods on which they depend.\r\n\r\n/**\r\n * An indicator used to reliably determine if an object is a Long or not.\r\n * @type {boolean}\r\n * @const\r\n * @private\r\n */\r\nLong.prototype.__isLong__;\r\n\r\nObject.defineProperty(Long.prototype, \"__isLong__\", { value: true });\r\n\r\n/**\r\n * @function\r\n * @param {*} obj Object\r\n * @returns {boolean}\r\n * @inner\r\n */\r\nfunction isLong(obj) {\r\n    return (obj && obj[\"__isLong__\"]) === true;\r\n}\r\n\r\n/**\r\n * Tests if the specified object is a Long.\r\n * @function\r\n * @param {*} obj Object\r\n * @returns {boolean}\r\n */\r\nLong.isLong = isLong;\r\n\r\n/**\r\n * A cache of the Long representations of small integer values.\r\n * @type {!Object}\r\n * @inner\r\n */\r\nvar INT_CACHE = {};\r\n\r\n/**\r\n * A cache of the Long representations of small unsigned integer values.\r\n * @type {!Object}\r\n * @inner\r\n */\r\nvar UINT_CACHE = {};\r\n\r\n/**\r\n * @param {number} value\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromInt(value, unsigned) {\r\n    var obj, cachedObj, cache;\r\n    if (unsigned) {\r\n        value >>>= 0;\r\n        if (cache = (0 <= value && value < 256)) {\r\n            cachedObj = UINT_CACHE[value];\r\n            if (cachedObj)\r\n                return cachedObj;\r\n        }\r\n        obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\r\n        if (cache)\r\n            UINT_CACHE[value] = obj;\r\n        return obj;\r\n    } else {\r\n        value |= 0;\r\n        if (cache = (-128 <= value && value < 128)) {\r\n            cachedObj = INT_CACHE[value];\r\n            if (cachedObj)\r\n                return cachedObj;\r\n        }\r\n        obj = fromBits(value, value < 0 ? -1 : 0, false);\r\n        if (cache)\r\n            INT_CACHE[value] = obj;\r\n        return obj;\r\n    }\r\n}\r\n\r\n/**\r\n * Returns a Long representing the given 32 bit integer value.\r\n * @function\r\n * @param {number} value The 32 bit integer in question\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromInt = fromInt;\r\n\r\n/**\r\n * @param {number} value\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromNumber(value, unsigned) {\r\n    if (isNaN(value))\r\n        return unsigned ? UZERO : ZERO;\r\n    if (unsigned) {\r\n        if (value < 0)\r\n            return UZERO;\r\n        if (value >= TWO_PWR_64_DBL)\r\n            return MAX_UNSIGNED_VALUE;\r\n    } else {\r\n        if (value <= -TWO_PWR_63_DBL)\r\n            return MIN_VALUE;\r\n        if (value + 1 >= TWO_PWR_63_DBL)\r\n            return MAX_VALUE;\r\n    }\r\n    if (value < 0)\r\n        return fromNumber(-value, unsigned).neg();\r\n    return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\r\n}\r\n\r\n/**\r\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\r\n * @function\r\n * @param {number} value The number in question\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromNumber = fromNumber;\r\n\r\n/**\r\n * @param {number} lowBits\r\n * @param {number} highBits\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromBits(lowBits, highBits, unsigned) {\r\n    return new Long(lowBits, highBits, unsigned);\r\n}\r\n\r\n/**\r\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\r\n *  assumed to use 32 bits.\r\n * @function\r\n * @param {number} lowBits The low 32 bits\r\n * @param {number} highBits The high 32 bits\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromBits = fromBits;\r\n\r\n/**\r\n * @function\r\n * @param {number} base\r\n * @param {number} exponent\r\n * @returns {number}\r\n * @inner\r\n */\r\nvar pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\r\n\r\n/**\r\n * @param {string} str\r\n * @param {(boolean|number)=} unsigned\r\n * @param {number=} radix\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromString(str, unsigned, radix) {\r\n    if (str.length === 0)\r\n        throw Error('empty string');\r\n    if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\r\n        return ZERO;\r\n    if (typeof unsigned === 'number') {\r\n        // For goog.math.long compatibility\r\n        radix = unsigned,\r\n        unsigned = false;\r\n    } else {\r\n        unsigned = !! unsigned;\r\n    }\r\n    radix = radix || 10;\r\n    if (radix < 2 || 36 < radix)\r\n        throw RangeError('radix');\r\n\r\n    var p;\r\n    if ((p = str.indexOf('-')) > 0)\r\n        throw Error('interior hyphen');\r\n    else if (p === 0) {\r\n        return fromString(str.substring(1), unsigned, radix).neg();\r\n    }\r\n\r\n    // Do several (8) digits each time through the loop, so as to\r\n    // minimize the calls to the very expensive emulated div.\r\n    var radixToPower = fromNumber(pow_dbl(radix, 8));\r\n\r\n    var result = ZERO;\r\n    for (var i = 0; i < str.length; i += 8) {\r\n        var size = Math.min(8, str.length - i),\r\n            value = parseInt(str.substring(i, i + size), radix);\r\n        if (size < 8) {\r\n            var power = fromNumber(pow_dbl(radix, size));\r\n            result = result.mul(power).add(fromNumber(value));\r\n        } else {\r\n            result = result.mul(radixToPower);\r\n            result = result.add(fromNumber(value));\r\n        }\r\n    }\r\n    result.unsigned = unsigned;\r\n    return result;\r\n}\r\n\r\n/**\r\n * Returns a Long representation of the given string, written using the specified radix.\r\n * @function\r\n * @param {string} str The textual representation of the Long\r\n * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\r\n * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromString = fromString;\r\n\r\n/**\r\n * @function\r\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromValue(val, unsigned) {\r\n    if (typeof val === 'number')\r\n        return fromNumber(val, unsigned);\r\n    if (typeof val === 'string')\r\n        return fromString(val, unsigned);\r\n    // Throws for non-objects, converts non-instanceof Long:\r\n    return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);\r\n}\r\n\r\n/**\r\n * Converts the specified value to a Long using the appropriate from* function for its type.\r\n * @function\r\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long}\r\n */\r\nLong.fromValue = fromValue;\r\n\r\n// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\r\n// no runtime penalty for these.\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_16_DBL = 1 << 16;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_24_DBL = 1 << 24;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\r\n\r\n/**\r\n * @type {!Long}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar ZERO = fromInt(0);\r\n\r\n/**\r\n * Signed zero.\r\n * @type {!Long}\r\n */\r\nLong.ZERO = ZERO;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar UZERO = fromInt(0, true);\r\n\r\n/**\r\n * Unsigned zero.\r\n * @type {!Long}\r\n */\r\nLong.UZERO = UZERO;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar ONE = fromInt(1);\r\n\r\n/**\r\n * Signed one.\r\n * @type {!Long}\r\n */\r\nLong.ONE = ONE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar UONE = fromInt(1, true);\r\n\r\n/**\r\n * Unsigned one.\r\n * @type {!Long}\r\n */\r\nLong.UONE = UONE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar NEG_ONE = fromInt(-1);\r\n\r\n/**\r\n * Signed negative one.\r\n * @type {!Long}\r\n */\r\nLong.NEG_ONE = NEG_ONE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);\r\n\r\n/**\r\n * Maximum signed value.\r\n * @type {!Long}\r\n */\r\nLong.MAX_VALUE = MAX_VALUE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);\r\n\r\n/**\r\n * Maximum unsigned value.\r\n * @type {!Long}\r\n */\r\nLong.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar MIN_VALUE = fromBits(0, 0x80000000|0, false);\r\n\r\n/**\r\n * Minimum signed value.\r\n * @type {!Long}\r\n */\r\nLong.MIN_VALUE = MIN_VALUE;\r\n\r\n/**\r\n * @alias Long.prototype\r\n * @inner\r\n */\r\nvar LongPrototype = Long.prototype;\r\n\r\n/**\r\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\r\n * @returns {number}\r\n */\r\nLongPrototype.toInt = function toInt() {\r\n    return this.unsigned ? this.low >>> 0 : this.low;\r\n};\r\n\r\n/**\r\n * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\r\n * @returns {number}\r\n */\r\nLongPrototype.toNumber = function toNumber() {\r\n    if (this.unsigned)\r\n        return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);\r\n    return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\r\n};\r\n\r\n/**\r\n * Converts the Long to a string written in the specified radix.\r\n * @param {number=} radix Radix (2-36), defaults to 10\r\n * @returns {string}\r\n * @override\r\n * @throws {RangeError} If `radix` is out of range\r\n */\r\nLongPrototype.toString = function toString(radix) {\r\n    radix = radix || 10;\r\n    if (radix < 2 || 36 < radix)\r\n        throw RangeError('radix');\r\n    if (this.isZero())\r\n        return '0';\r\n    if (this.isNegative()) { // Unsigned Longs are never negative\r\n        if (this.eq(MIN_VALUE)) {\r\n            // We need to change the Long value before it can be negated, so we remove\r\n            // the bottom-most digit in this base and then recurse to do the rest.\r\n            var radixLong = fromNumber(radix),\r\n                div = this.div(radixLong),\r\n                rem1 = div.mul(radixLong).sub(this);\r\n            return div.toString(radix) + rem1.toInt().toString(radix);\r\n        } else\r\n            return '-' + this.neg().toString(radix);\r\n    }\r\n\r\n    // Do several (6) digits each time through the loop, so as to\r\n    // minimize the calls to the very expensive emulated div.\r\n    var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\r\n        rem = this;\r\n    var result = '';\r\n    while (true) {\r\n        var remDiv = rem.div(radixToPower),\r\n            intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\r\n            digits = intval.toString(radix);\r\n        rem = remDiv;\r\n        if (rem.isZero())\r\n            return digits + result;\r\n        else {\r\n            while (digits.length < 6)\r\n                digits = '0' + digits;\r\n            result = '' + digits + result;\r\n        }\r\n    }\r\n};\r\n\r\n/**\r\n * Gets the high 32 bits as a signed integer.\r\n * @returns {number} Signed high bits\r\n */\r\nLongPrototype.getHighBits = function getHighBits() {\r\n    return this.high;\r\n};\r\n\r\n/**\r\n * Gets the high 32 bits as an unsigned integer.\r\n * @returns {number} Unsigned high bits\r\n */\r\nLongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\r\n    return this.high >>> 0;\r\n};\r\n\r\n/**\r\n * Gets the low 32 bits as a signed integer.\r\n * @returns {number} Signed low bits\r\n */\r\nLongPrototype.getLowBits = function getLowBits() {\r\n    return this.low;\r\n};\r\n\r\n/**\r\n * Gets the low 32 bits as an unsigned integer.\r\n * @returns {number} Unsigned low bits\r\n */\r\nLongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\r\n    return this.low >>> 0;\r\n};\r\n\r\n/**\r\n * Gets the number of bits needed to represent the absolute value of this Long.\r\n * @returns {number}\r\n */\r\nLongPrototype.getNumBitsAbs = function getNumBitsAbs() {\r\n    if (this.isNegative()) // Unsigned Longs are never negative\r\n        return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\r\n    var val = this.high != 0 ? this.high : this.low;\r\n    for (var bit = 31; bit > 0; bit--)\r\n        if ((val & (1 << bit)) != 0)\r\n            break;\r\n    return this.high != 0 ? bit + 33 : bit + 1;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals zero.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isZero = function isZero() {\r\n    return this.high === 0 && this.low === 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.eqz = LongPrototype.isZero;\r\n\r\n/**\r\n * Tests if this Long's value is negative.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isNegative = function isNegative() {\r\n    return !this.unsigned && this.high < 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is positive.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isPositive = function isPositive() {\r\n    return this.unsigned || this.high >= 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is odd.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isOdd = function isOdd() {\r\n    return (this.low & 1) === 1;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is even.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isEven = function isEven() {\r\n    return (this.low & 1) === 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.equals = function equals(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)\r\n        return false;\r\n    return this.high === other.high && this.low === other.low;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.eq = LongPrototype.equals;\r\n\r\n/**\r\n * Tests if this Long's value differs from the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.notEquals = function notEquals(other) {\r\n    return !this.eq(/* validates */ other);\r\n};\r\n\r\n/**\r\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.neq = LongPrototype.notEquals;\r\n\r\n/**\r\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.ne = LongPrototype.notEquals;\r\n\r\n/**\r\n * Tests if this Long's value is less than the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lessThan = function lessThan(other) {\r\n    return this.comp(/* validates */ other) < 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lt = LongPrototype.lessThan;\r\n\r\n/**\r\n * Tests if this Long's value is less than or equal the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\r\n    return this.comp(/* validates */ other) <= 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lte = LongPrototype.lessThanOrEqual;\r\n\r\n/**\r\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.le = LongPrototype.lessThanOrEqual;\r\n\r\n/**\r\n * Tests if this Long's value is greater than the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.greaterThan = function greaterThan(other) {\r\n    return this.comp(/* validates */ other) > 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.gt = LongPrototype.greaterThan;\r\n\r\n/**\r\n * Tests if this Long's value is greater than or equal the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\r\n    return this.comp(/* validates */ other) >= 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.gte = LongPrototype.greaterThanOrEqual;\r\n\r\n/**\r\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.ge = LongPrototype.greaterThanOrEqual;\r\n\r\n/**\r\n * Compares this Long's value with the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n *  if the given one is greater\r\n */\r\nLongPrototype.compare = function compare(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    if (this.eq(other))\r\n        return 0;\r\n    var thisNeg = this.isNegative(),\r\n        otherNeg = other.isNegative();\r\n    if (thisNeg && !otherNeg)\r\n        return -1;\r\n    if (!thisNeg && otherNeg)\r\n        return 1;\r\n    // At this point the sign bits are the same\r\n    if (!this.unsigned)\r\n        return this.sub(other).isNegative() ? -1 : 1;\r\n    // Both are positive if at least one is unsigned\r\n    return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;\r\n};\r\n\r\n/**\r\n * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n *  if the given one is greater\r\n */\r\nLongPrototype.comp = LongPrototype.compare;\r\n\r\n/**\r\n * Negates this Long's value.\r\n * @returns {!Long} Negated Long\r\n */\r\nLongPrototype.negate = function negate() {\r\n    if (!this.unsigned && this.eq(MIN_VALUE))\r\n        return MIN_VALUE;\r\n    return this.not().add(ONE);\r\n};\r\n\r\n/**\r\n * Negates this Long's value. This is an alias of {@link Long#negate}.\r\n * @function\r\n * @returns {!Long} Negated Long\r\n */\r\nLongPrototype.neg = LongPrototype.negate;\r\n\r\n/**\r\n * Returns the sum of this and the specified Long.\r\n * @param {!Long|number|string} addend Addend\r\n * @returns {!Long} Sum\r\n */\r\nLongPrototype.add = function add(addend) {\r\n    if (!isLong(addend))\r\n        addend = fromValue(addend);\r\n\r\n    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\r\n\r\n    var a48 = this.high >>> 16;\r\n    var a32 = this.high & 0xFFFF;\r\n    var a16 = this.low >>> 16;\r\n    var a00 = this.low & 0xFFFF;\r\n\r\n    var b48 = addend.high >>> 16;\r\n    var b32 = addend.high & 0xFFFF;\r\n    var b16 = addend.low >>> 16;\r\n    var b00 = addend.low & 0xFFFF;\r\n\r\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n    c00 += a00 + b00;\r\n    c16 += c00 >>> 16;\r\n    c00 &= 0xFFFF;\r\n    c16 += a16 + b16;\r\n    c32 += c16 >>> 16;\r\n    c16 &= 0xFFFF;\r\n    c32 += a32 + b32;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c48 += a48 + b48;\r\n    c48 &= 0xFFFF;\r\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the difference of this and the specified Long.\r\n * @param {!Long|number|string} subtrahend Subtrahend\r\n * @returns {!Long} Difference\r\n */\r\nLongPrototype.subtract = function subtract(subtrahend) {\r\n    if (!isLong(subtrahend))\r\n        subtrahend = fromValue(subtrahend);\r\n    return this.add(subtrahend.neg());\r\n};\r\n\r\n/**\r\n * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\r\n * @function\r\n * @param {!Long|number|string} subtrahend Subtrahend\r\n * @returns {!Long} Difference\r\n */\r\nLongPrototype.sub = LongPrototype.subtract;\r\n\r\n/**\r\n * Returns the product of this and the specified Long.\r\n * @param {!Long|number|string} multiplier Multiplier\r\n * @returns {!Long} Product\r\n */\r\nLongPrototype.multiply = function multiply(multiplier) {\r\n    if (this.isZero())\r\n        return ZERO;\r\n    if (!isLong(multiplier))\r\n        multiplier = fromValue(multiplier);\r\n\r\n    // use wasm support if present\r\n    if (wasm) {\r\n        var low = wasm.mul(this.low,\r\n                           this.high,\r\n                           multiplier.low,\r\n                           multiplier.high);\r\n        return fromBits(low, wasm.get_high(), this.unsigned);\r\n    }\r\n\r\n    if (multiplier.isZero())\r\n        return ZERO;\r\n    if (this.eq(MIN_VALUE))\r\n        return multiplier.isOdd() ? MIN_VALUE : ZERO;\r\n    if (multiplier.eq(MIN_VALUE))\r\n        return this.isOdd() ? MIN_VALUE : ZERO;\r\n\r\n    if (this.isNegative()) {\r\n        if (multiplier.isNegative())\r\n            return this.neg().mul(multiplier.neg());\r\n        else\r\n            return this.neg().mul(multiplier).neg();\r\n    } else if (multiplier.isNegative())\r\n        return this.mul(multiplier.neg()).neg();\r\n\r\n    // If both longs are small, use float multiplication\r\n    if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\r\n        return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\r\n\r\n    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\r\n    // We can skip products that would overflow.\r\n\r\n    var a48 = this.high >>> 16;\r\n    var a32 = this.high & 0xFFFF;\r\n    var a16 = this.low >>> 16;\r\n    var a00 = this.low & 0xFFFF;\r\n\r\n    var b48 = multiplier.high >>> 16;\r\n    var b32 = multiplier.high & 0xFFFF;\r\n    var b16 = multiplier.low >>> 16;\r\n    var b00 = multiplier.low & 0xFFFF;\r\n\r\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n    c00 += a00 * b00;\r\n    c16 += c00 >>> 16;\r\n    c00 &= 0xFFFF;\r\n    c16 += a16 * b00;\r\n    c32 += c16 >>> 16;\r\n    c16 &= 0xFFFF;\r\n    c16 += a00 * b16;\r\n    c32 += c16 >>> 16;\r\n    c16 &= 0xFFFF;\r\n    c32 += a32 * b00;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c32 += a16 * b16;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c32 += a00 * b32;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\r\n    c48 &= 0xFFFF;\r\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\r\n * @function\r\n * @param {!Long|number|string} multiplier Multiplier\r\n * @returns {!Long} Product\r\n */\r\nLongPrototype.mul = LongPrototype.multiply;\r\n\r\n/**\r\n * Returns this Long divided by the specified. The result is signed if this Long is signed or\r\n *  unsigned if this Long is unsigned.\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Quotient\r\n */\r\nLongPrototype.divide = function divide(divisor) {\r\n    if (!isLong(divisor))\r\n        divisor = fromValue(divisor);\r\n    if (divisor.isZero())\r\n        throw Error('division by zero');\r\n\r\n    // use wasm support if present\r\n    if (wasm) {\r\n        // guard against signed division overflow: the largest\r\n        // negative number / -1 would be 1 larger than the largest\r\n        // positive number, due to two's complement.\r\n        if (!this.unsigned &&\r\n            this.high === -0x80000000 &&\r\n            divisor.low === -1 && divisor.high === -1) {\r\n            // be consistent with non-wasm code path\r\n            return this;\r\n        }\r\n        var low = (this.unsigned ? wasm.div_u : wasm.div_s)(\r\n            this.low,\r\n            this.high,\r\n            divisor.low,\r\n            divisor.high\r\n        );\r\n        return fromBits(low, wasm.get_high(), this.unsigned);\r\n    }\r\n\r\n    if (this.isZero())\r\n        return this.unsigned ? UZERO : ZERO;\r\n    var approx, rem, res;\r\n    if (!this.unsigned) {\r\n        // This section is only relevant for signed longs and is derived from the\r\n        // closure library as a whole.\r\n        if (this.eq(MIN_VALUE)) {\r\n            if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\r\n                return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE\r\n            else if (divisor.eq(MIN_VALUE))\r\n                return ONE;\r\n            else {\r\n                // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\r\n                var halfThis = this.shr(1);\r\n                approx = halfThis.div(divisor).shl(1);\r\n                if (approx.eq(ZERO)) {\r\n                    return divisor.isNegative() ? ONE : NEG_ONE;\r\n                } else {\r\n                    rem = this.sub(divisor.mul(approx));\r\n                    res = approx.add(rem.div(divisor));\r\n                    return res;\r\n                }\r\n            }\r\n        } else if (divisor.eq(MIN_VALUE))\r\n            return this.unsigned ? UZERO : ZERO;\r\n        if (this.isNegative()) {\r\n            if (divisor.isNegative())\r\n                return this.neg().div(divisor.neg());\r\n            return this.neg().div(divisor).neg();\r\n        } else if (divisor.isNegative())\r\n            return this.div(divisor.neg()).neg();\r\n        res = ZERO;\r\n    } else {\r\n        // The algorithm below has not been made for unsigned longs. It's therefore\r\n        // required to take special care of the MSB prior to running it.\r\n        if (!divisor.unsigned)\r\n            divisor = divisor.toUnsigned();\r\n        if (divisor.gt(this))\r\n            return UZERO;\r\n        if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\r\n            return UONE;\r\n        res = UZERO;\r\n    }\r\n\r\n    // Repeat the following until the remainder is less than other:  find a\r\n    // floating-point that approximates remainder / other *from below*, add this\r\n    // into the result, and subtract it from the remainder.  It is critical that\r\n    // the approximate value is less than or equal to the real value so that the\r\n    // remainder never becomes negative.\r\n    rem = this;\r\n    while (rem.gte(divisor)) {\r\n        // Approximate the result of division. This may be a little greater or\r\n        // smaller than the actual value.\r\n        approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\r\n\r\n        // We will tweak the approximate result by changing it in the 48-th digit or\r\n        // the smallest non-fractional digit, whichever is larger.\r\n        var log2 = Math.ceil(Math.log(approx) / Math.LN2),\r\n            delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),\r\n\r\n        // Decrease the approximation until it is smaller than the remainder.  Note\r\n        // that if it is too large, the product overflows and is negative.\r\n            approxRes = fromNumber(approx),\r\n            approxRem = approxRes.mul(divisor);\r\n        while (approxRem.isNegative() || approxRem.gt(rem)) {\r\n            approx -= delta;\r\n            approxRes = fromNumber(approx, this.unsigned);\r\n            approxRem = approxRes.mul(divisor);\r\n        }\r\n\r\n        // We know the answer can't be zero... and actually, zero would cause\r\n        // infinite recursion since we would make no progress.\r\n        if (approxRes.isZero())\r\n            approxRes = ONE;\r\n\r\n        res = res.add(approxRes);\r\n        rem = rem.sub(approxRem);\r\n    }\r\n    return res;\r\n};\r\n\r\n/**\r\n * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\r\n * @function\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Quotient\r\n */\r\nLongPrototype.div = LongPrototype.divide;\r\n\r\n/**\r\n * Returns this Long modulo the specified.\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Remainder\r\n */\r\nLongPrototype.modulo = function modulo(divisor) {\r\n    if (!isLong(divisor))\r\n        divisor = fromValue(divisor);\r\n\r\n    // use wasm support if present\r\n    if (wasm) {\r\n        var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(\r\n            this.low,\r\n            this.high,\r\n            divisor.low,\r\n            divisor.high\r\n        );\r\n        return fromBits(low, wasm.get_high(), this.unsigned);\r\n    }\r\n\r\n    return this.sub(this.div(divisor).mul(divisor));\r\n};\r\n\r\n/**\r\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n * @function\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Remainder\r\n */\r\nLongPrototype.mod = LongPrototype.modulo;\r\n\r\n/**\r\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n * @function\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Remainder\r\n */\r\nLongPrototype.rem = LongPrototype.modulo;\r\n\r\n/**\r\n * Returns the bitwise NOT of this Long.\r\n * @returns {!Long}\r\n */\r\nLongPrototype.not = function not() {\r\n    return fromBits(~this.low, ~this.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the bitwise AND of this Long and the specified.\r\n * @param {!Long|number|string} other Other Long\r\n * @returns {!Long}\r\n */\r\nLongPrototype.and = function and(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the bitwise OR of this Long and the specified.\r\n * @param {!Long|number|string} other Other Long\r\n * @returns {!Long}\r\n */\r\nLongPrototype.or = function or(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the bitwise XOR of this Long and the given one.\r\n * @param {!Long|number|string} other Other Long\r\n * @returns {!Long}\r\n */\r\nLongPrototype.xor = function xor(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns this Long with bits shifted to the left by the given amount.\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shiftLeft = function shiftLeft(numBits) {\r\n    if (isLong(numBits))\r\n        numBits = numBits.toInt();\r\n    if ((numBits &= 63) === 0)\r\n        return this;\r\n    else if (numBits < 32)\r\n        return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);\r\n    else\r\n        return fromBits(0, this.low << (numBits - 32), this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shl = LongPrototype.shiftLeft;\r\n\r\n/**\r\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shiftRight = function shiftRight(numBits) {\r\n    if (isLong(numBits))\r\n        numBits = numBits.toInt();\r\n    if ((numBits &= 63) === 0)\r\n        return this;\r\n    else if (numBits < 32)\r\n        return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);\r\n    else\r\n        return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shr = LongPrototype.shiftRight;\r\n\r\n/**\r\n * Returns this Long with bits logically shifted to the right by the given amount.\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\r\n    if (isLong(numBits))\r\n        numBits = numBits.toInt();\r\n    numBits &= 63;\r\n    if (numBits === 0)\r\n        return this;\r\n    else {\r\n        var high = this.high;\r\n        if (numBits < 32) {\r\n            var low = this.low;\r\n            return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);\r\n        } else if (numBits === 32)\r\n            return fromBits(high, 0, this.unsigned);\r\n        else\r\n            return fromBits(high >>> (numBits - 32), 0, this.unsigned);\r\n    }\r\n};\r\n\r\n/**\r\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shru = LongPrototype.shiftRightUnsigned;\r\n\r\n/**\r\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\r\n\r\n/**\r\n * Converts this Long to signed.\r\n * @returns {!Long} Signed long\r\n */\r\nLongPrototype.toSigned = function toSigned() {\r\n    if (!this.unsigned)\r\n        return this;\r\n    return fromBits(this.low, this.high, false);\r\n};\r\n\r\n/**\r\n * Converts this Long to unsigned.\r\n * @returns {!Long} Unsigned long\r\n */\r\nLongPrototype.toUnsigned = function toUnsigned() {\r\n    if (this.unsigned)\r\n        return this;\r\n    return fromBits(this.low, this.high, true);\r\n};\r\n\r\n/**\r\n * Converts this Long to its byte representation.\r\n * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n * @returns {!Array.<number>} Byte representation\r\n */\r\nLongPrototype.toBytes = function toBytes(le) {\r\n    return le ? this.toBytesLE() : this.toBytesBE();\r\n};\r\n\r\n/**\r\n * Converts this Long to its little endian byte representation.\r\n * @returns {!Array.<number>} Little endian byte representation\r\n */\r\nLongPrototype.toBytesLE = function toBytesLE() {\r\n    var hi = this.high,\r\n        lo = this.low;\r\n    return [\r\n        lo        & 0xff,\r\n        lo >>>  8 & 0xff,\r\n        lo >>> 16 & 0xff,\r\n        lo >>> 24       ,\r\n        hi        & 0xff,\r\n        hi >>>  8 & 0xff,\r\n        hi >>> 16 & 0xff,\r\n        hi >>> 24\r\n    ];\r\n};\r\n\r\n/**\r\n * Converts this Long to its big endian byte representation.\r\n * @returns {!Array.<number>} Big endian byte representation\r\n */\r\nLongPrototype.toBytesBE = function toBytesBE() {\r\n    var hi = this.high,\r\n        lo = this.low;\r\n    return [\r\n        hi >>> 24       ,\r\n        hi >>> 16 & 0xff,\r\n        hi >>>  8 & 0xff,\r\n        hi        & 0xff,\r\n        lo >>> 24       ,\r\n        lo >>> 16 & 0xff,\r\n        lo >>>  8 & 0xff,\r\n        lo        & 0xff\r\n    ];\r\n};\r\n\r\n/**\r\n * Creates a Long from its byte representation.\r\n * @param {!Array.<number>} bytes Byte representation\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n * @returns {Long} The corresponding Long value\r\n */\r\nLong.fromBytes = function fromBytes(bytes, unsigned, le) {\r\n    return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);\r\n};\r\n\r\n/**\r\n * Creates a Long from its little endian byte representation.\r\n * @param {!Array.<number>} bytes Little endian byte representation\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {Long} The corresponding Long value\r\n */\r\nLong.fromBytesLE = function fromBytesLE(bytes, unsigned) {\r\n    return new Long(\r\n        bytes[0]       |\r\n        bytes[1] <<  8 |\r\n        bytes[2] << 16 |\r\n        bytes[3] << 24,\r\n        bytes[4]       |\r\n        bytes[5] <<  8 |\r\n        bytes[6] << 16 |\r\n        bytes[7] << 24,\r\n        unsigned\r\n    );\r\n};\r\n\r\n/**\r\n * Creates a Long from its big endian byte representation.\r\n * @param {!Array.<number>} bytes Big endian byte representation\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {Long} The corresponding Long value\r\n */\r\nLong.fromBytesBE = function fromBytesBE(bytes, unsigned) {\r\n    return new Long(\r\n        bytes[4] << 24 |\r\n        bytes[5] << 16 |\r\n        bytes[6] <<  8 |\r\n        bytes[7],\r\n        bytes[0] << 24 |\r\n        bytes[1] << 16 |\r\n        bytes[2] <<  8 |\r\n        bytes[3],\r\n        unsigned\r\n    );\r\n};\r\n\n\n/***/ })\n/******/ ]);","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport BSON from './../../../../third_party/bson.common.js';\n\nconst bson = BSON.bson;\n\nclass Bson {\n    /**\n     * Serialize a Javascript object.\n     *\n     * @param object The Javascript object to serialize.\n     * @return The Buffer object containing the serialized object.\n     */\n    static serialize (object) {\n        return bson.serialize(object);\n    }\n\n    /**\n     * Deserialize data as BSON.\n     *\n     * @param buffer The buffer containing the serialized set of BSON documents.\n     * @returns The deserialized Javascript Object.\n     */\n    static deserialize (object) {\n        return bson.deserialize(object);\n    }\n}\n\nexport { Bson };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FrameType } from './enums/FrameType.js';\nimport  { Bson } from './../util/Bson.js';\n\n/**\n * @typedef {Object} SdlPacket\n * @property {number} _EXTRA_PARCEL_DATA_LENGTH\n * @property @private {number} _HEADER_SIZE\n * @property @private {number} _HEADER_SIZE_V1\n * @property @private {number} _ENCRYPTION_MASK\n * @property {number} SERVICE_TYPE_CONTROL\n * @property {number} SERVICE_TYPE_RPC\n * @property {number} SERVICE_TYPE_PCM\n * @property {number} SERVICE_TYPE_VIDEO\n * @property {number} SERVICE_TYPE_BULK_DATA\n * @property {number} FRAME_INFO_HEART_BEAT\n * @property {number} FRAME_INFO_START_SERVICE\n * @property {number} FRAME_INFO_START_SERVICE_ACK\n * @property {number} FRAME_INFO_START_SERVICE_NAK\n * @property {number} FRAME_INFO_END_SERVICE\n * @property {number} FRAME_INFO_END_SERVICE_ACK\n * @property {number} FRAME_INFO_END_SERVICE_NAK\n * @property {number} FRAME_INFO_REGISTER_SECONDARY_TRANSPORT\n * @property {number} FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_ACK\n * @property {number} FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_NAK\n * @property {number} FRAME_INFO_TRANSPORT_EVENT_UPDATE\n * @property {number} FRAME_INFO_SERVICE_DATA_ACK\n * @property {number} FRAME_INFO_HEART_BEAT_ACK\n * @property {number} FRAME_INFO_FINAL_CONNESCUTIVE_FRAME\n * @property {number} FRAME_INFO_RESERVED\n\n * @property {function} getVersion\n * @property {function} getEncryption\n * @property {function} getServiceType\n * @property {function} getFrameInfo\n * @property {function} getSessionID\n * @property {function} getMessageID\n * @property {function} getDataSize\n * @property {function} setPayload\n * @property {function} getPayload\n * @property {function} getEncryptionBit\n * @property {function} getFrameType\n * @property {function} toUint8Array\n * @property {function} toString\n * @property @private {function} _constructPacket\n * @property {function} putTag\n * @property {function} getTag\n */\n\nclass SdlPacket {\n    /**\n    * @constructor\n    * @param {Number} version - Protocol version to use\n    * @param {Boolean} encryption - Whether or not the payload in this packet is encrypted\n    * @param {FrameType} frameType - A number representing the packet frame type\n    * @param {ServiceType} serviceType - The service that this packet is associated with\n    * @param {Number} frameInfo - Specific frame info related to this packet\n    * @param {Number} sessionID - ID this packet is associated with\n    * @param {Number} dataSize - Size of the payload that will be added\n    * @param {Number} messageID - ID of this specific packet\n    * @param {Uint8Array} payload - Raw data that will be attached to the packet (RPC message, raw bytes, etc)\n    * @param {Number} offset\n    * @param {Number} bytesToWrite\n    */\n    constructor (version = 1, encryption = false, frameType = -1, serviceType = -1, frameInfo = -1, sessionID = 0, dataSize = 0, messageID = 0, payload = null, offset = 0, bytesToWrite = 0) {\n        this._version = version;\n        this._encryption = encryption;\n        this._frameType = frameType;\n        this._serviceType = serviceType;\n        this._frameInfo = frameInfo;\n        this._sessionID = sessionID;\n        this._dataSize = dataSize;\n        this._messageID = messageID;\n        this._payload = payload;\n        this._offset = offset;\n        this._bytesToWrite = bytesToWrite;\n\n        this._bsonPayload = undefined;\n\n        if (payload !== null) {\n            this._payload = new Uint8Array(payload.slice(offset, bytesToWrite + offset));\n        }\n\n        return this;\n    }\n\n    /**\n    * @return {Number} - Protocol version used by this packet\n    */\n    getVersion () {\n        return this._version;\n    }\n\n    /**\n    * @return {Boolean} - Whether or not the payload in this packet is encrypted\n    */\n    getEncryption () {\n        return this._encryption;\n    }\n\n    /**\n    * @return {ServiceType} - The service that this packet is associated with\n    */\n    getServiceType () {\n        return this._serviceType;\n    }\n\n    /**\n    * @return {Number} - Specific frame info related to this packet\n    */\n    getFrameInfo () {\n        return this._frameInfo;\n    }\n\n    /**\n    * @return {Number} - ID this packet is associated with\n    */\n    getSessionID () {\n        return this._sessionID;\n    }\n\n    /**\n    * @return {Number} - ID of this specific packet\n    */\n    getMessageID () {\n        return this._messageID;\n    }\n\n    /**\n    * @return {Number} - Size of the payload that will be added\n    */\n    getDataSize () {\n        return this._dataSize;\n    }\n\n    /**\n    * @param {Uint8Array} payload\n    * @return {SdlPacket}\n    */\n    setPayload (payload) {\n        this._payload = payload;\n        return this;\n    }\n\n    /**\n    * @return {Uint8Array} - Raw data that will be attached to the packet (RPC message, raw bytes, etc)\n    */\n    getPayload () {\n        return this._payload;\n    }\n\n\n    /**\n     *\n     * @param {Boolean} encryption\n     * @return {Number} - Returns a number representing a byte mask depending on the boolean value\n     */\n    static getEncryptionBit (encryption) {\n        return encryption ? SdlPacket._ENCRYPTION_MASK : 0;\n    }\n\n    /**\n    * @return {FrameType} - A number representing the packet frame type\n    */\n    getFrameType () {\n        if (FrameType.keyForValue(this._frameType) !== null) {\n            return this._frameType;\n        } else {\n            return FrameType.SINGLE;\n        }\n    }\n\n    /**\n    * @return {String} - String representation of the packet\n    */\n    toString () {\n        let output = '***** Sdl Packet *****';\n        output += `\\nVersion: ${this._version}`;\n        output += `\\nEncryption: ${this._encryption}`;\n        output += `\\nFrameType: ${this._frameType}`;\n        output += `\\nServiceType: ${this._serviceType}`;\n        output += `\\nFrameInfo: ${this._frameInfo}`;\n        output += `\\nSessionID: ${this._sessionID}`;\n        output += `\\nDataSize: ${this._dataSize}`;\n\n        if (this._version > 1) {\n            output += `\\nMessageID: ${this._messageID}`;\n        }\n\n        output += '\\n***** Sdl Packet End *****';\n\n        return output;\n    }\n\n    /**\n\t * This method takes in the various components to the SDL packet structure and creates a new byte array that can be sent via the transport\n     * @param {Number} version - Protocol version to use\n     * @param {Boolean} encryption - Whether or not the payload in this packet is encrypted\n     * @param {FrameType} frameType - A number representing the packet frame type\n     * @param {ServiceType} serviceType - The service that this packet is associated with\n     * @param {Number} controlFrameInfo - Specific frame info related to this packet\n     * @param {Number} sessionID - ID this packet is associated with\n     * @param {Number} dataSize - Size of the payload that will be added\n     * @param {Number} messageID - ID of this specific packet\n     * @param {Uint8Array} payload - Raw data that will be attached to the packet (RPC message, raw bytes, etc)\n\t * @return {Uint8Array} - A byte[] representation of an SdlPacket built using the supplied params\n\t */\n    static _constructPacket (version, encryption, frameType, serviceType, controlFrameInfo, sessionID, dataSize, messageID, payload) {\n        let dataView = null;\n        let dataViewIndex = 0;\n\n        if (version > 1) {\n            dataView = new Uint8Array(SdlPacket._HEADER_SIZE + dataSize);\n        } else {\n            dataView = new Uint8Array(SdlPacket._HEADER_SIZE_V1 + dataSize);\n        }\n\n        dataView[dataViewIndex++] = (version << 4) + SdlPacket.getEncryptionBit(encryption) + frameType;\n        dataView[dataViewIndex++] = serviceType;\n        dataView[dataViewIndex++] = controlFrameInfo;\n        dataView[dataViewIndex++] = sessionID;\n        dataView[dataViewIndex++] = (dataSize & 0xFF000000) >> 24;\n        dataView[dataViewIndex++] = (dataSize & 0x00FF0000) >> 16;\n        dataView[dataViewIndex++] = (dataSize & 0x0000FF00) >> 8;\n        dataView[dataViewIndex++] = dataSize & 0x000000FF;\n\n        if (version > 1) {\n            dataView[dataViewIndex++] = (messageID & 0xFF000000) >> 24;\n            dataView[dataViewIndex++] = (messageID & 0x00FF0000) >> 16;\n            dataView[dataViewIndex++] = (messageID & 0x0000FF00) >> 8;\n            dataView[dataViewIndex++] = messageID & 0x000000FF;\n        }\n\n        if (payload !== null && payload.length > 0) {\n            dataView.set(payload, dataViewIndex);\n        }\n\n        return dataView;\n    }\n\n    /**\n\t * This method converts an SdlPacket instance to a new byte array that can be sent via the transport\n\t * @return {Uint8Array} - A byte[] representation of an SdlPacket built using the supplied params\n\t */\n    toPacket () {\n        if (this._bsonPayload) {\n            this._payload = Bson.serialize(this._bsonPayload);\n            this._dataSize = this._payload.length;\n        }\n\n        return SdlPacket._constructPacket(this._version, this._encryption, this._frameType, this._serviceType, this._frameInfo, this._sessionID, this._dataSize, this._messageID, this._payload);\n    }\n\n    /**\n     * @param {String} tag - String key to add as a property to the BSON map\n     * @param {Object} data - Object to add as a value to the BSON map\n     */\n    putTag (tag, data) {\n        if (!this._bsonPayload) {\n            this._bsonPayload = {};\n        }\n        this._bsonPayload[tag] = data;\n    }\n\n    /**\n     * @param {String} tag - String key to add as a property to the BSON map\n     * @return {Object} data - Object as a value found from the the BSON map\n     */\n\n    getTag (tag) {\n        if (!this._bsonPayload) {\n            if (!this._payload || this._payload.length === 0) {\n                return null;\n            }\n            this._bsonPayload = Bson.deserialize(this._payload);\n            return this._bsonPayload[tag];\n        } else {\n            return this._bsonPayload[tag];\n        }\n    }\n}\n\nSdlPacket._EXTRA_PARCEL_DATA_LENGTH                      = 24;\nSdlPacket._HEADER_SIZE                                   = 12;\nSdlPacket._HEADER_SIZE_V1                                = 8;\n\nSdlPacket._ENCRYPTION_MASK                               = 0x08;\n\n/**\n * Service Type\n */\nSdlPacket.SERVICE_TYPE_CONTROL                          = 0x00;\n// RESERVED 0x01 - 0x06\nSdlPacket.SERVICE_TYPE_RPC                              = 0x07;\n// RESERVED 0x08 - 0x09\nSdlPacket.SERVICE_TYPE_PCM                              = 0x0A;\nSdlPacket.SERVICE_TYPE_VIDEO                            = 0x0B;\n// RESERVED 0x0C - 0x0E\nSdlPacket.SERVICE_TYPE_BULK_DATA                        = 0x0F;\n// RESERVED 0x10 - 0xFF\n\n/**\n * Frame Info\n */\nSdlPacket.FRAME_INFO_HEART_BEAT                         = 0x00;\nSdlPacket.FRAME_INFO_START_SERVICE                      = 0x01;\nSdlPacket.FRAME_INFO_START_SERVICE_ACK                  = 0x02;\nSdlPacket.FRAME_INFO_START_SERVICE_NAK                  = 0x03;\nSdlPacket.FRAME_INFO_END_SERVICE                        = 0x04;\nSdlPacket.FRAME_INFO_END_SERVICE_ACK                    = 0x05;\nSdlPacket.FRAME_INFO_END_SERVICE_NAK                    = 0x06;\nSdlPacket.FRAME_INFO_REGISTER_SECONDARY_TRANSPORT       = 0x07;\nSdlPacket.FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_ACK   = 0x08;\nSdlPacket.FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_NAK   = 0x09;\n// 0x0A-0xFC are reserved\nSdlPacket.FRAME_INFO_TRANSPORT_EVENT_UPDATE             = 0xFD;\nSdlPacket.FRAME_INFO_SERVICE_DATA_ACK                   = 0xFE;\nSdlPacket.FRAME_INFO_HEART_BEAT_ACK                     = 0xFF;\nSdlPacket.FRAME_INFO_FINAL_CONNESCUTIVE_FRAME           = 0x00;\nSdlPacket.FRAME_INFO_RESERVED                           = 0x00;\n\nexport { SdlPacket };\n","export default (typeof global !== \"undefined\" ? global :\n            typeof self !== \"undefined\" ? self :\n            typeof window !== \"undefined\" ? window : {});\n","\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\nvar inited = false;\nfunction init () {\n  inited = true;\n  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\n  for (var i = 0, len = code.length; i < len; ++i) {\n    lookup[i] = code[i]\n    revLookup[code.charCodeAt(i)] = i\n  }\n\n  revLookup['-'.charCodeAt(0)] = 62\n  revLookup['_'.charCodeAt(0)] = 63\n}\n\nexport function toByteArray (b64) {\n  if (!inited) {\n    init();\n  }\n  var i, j, l, tmp, placeHolders, arr\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n\n  // base64 is 4/3 + up to two characters of the original data\n  arr = new Arr(len * 3 / 4 - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nexport function fromByteArray (uint8) {\n  if (!inited) {\n    init();\n  }\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var output = ''\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n","\nexport function read (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexport function write (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nexport default Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n\nimport * as base64 from './base64'\nimport * as ieee754 from './ieee754'\nimport isArray from './isArray'\n\nexport var INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : true\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nvar _kMaxLength = kMaxLength()\nexport {_kMaxLength as kMaxLength};\nfunction typedArraySupport () {\n  return true;\n  // rollup issues\n  // try {\n  //   var arr = new Uint8Array(1)\n  //   arr.__proto__ = {\n  //     __proto__: Uint8Array.prototype,\n  //     foo: function () { return 42 }\n  //   }\n  //   return arr.foo() === 42 && // typed array instances can be augmented\n  //       typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n  //       arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  // } catch (e) {\n  //   return false\n  // }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nexport function Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    // Object.defineProperty(Buffer, Symbol.species, {\n    //   value: null,\n    //   configurable: true\n    // })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (internalIsBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nexport function SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\nBuffer.isBuffer = isBuffer;\nfunction internalIsBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!internalIsBuffer(a) || !internalIsBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!internalIsBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (internalIsBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!internalIsBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (internalIsBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!internalIsBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = internalIsBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n\n\n// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nexport function isBuffer(obj) {\n  return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))\n}\n\nfunction isFastBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))\n}\n","class TextEncoder {\n    // https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder#Polyfill\n    static encode (str) {\n        const Len = str.length;\n        let resPos = -1;\n        // The Uint8Array's length must be at least 3x the length of the string because an invalid UTF-16\n        //  takes up the equivelent space of 3 UTF-8 characters to encode it properly. However, Array's\n        //  have an auto expanding length and 1.5x should be just the right balance for most uses.\n        const resArr = [];\n        for (let point = 0, nextcode = 0, idx = 0; idx !== Len;) {\n            point = str.charCodeAt(idx), idx += 1;\n            if (point >= 0xD800 && point <= 0xDBFF) {\n                if (idx === Len) {\n                    resArr[resPos += 1] = 0xef;\n                    resArr[resPos += 1] = 0xbf;\n                    resArr[resPos += 1] = 0xbd;\n                    break;\n                }\n                // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n                nextcode = str.charCodeAt(idx);\n                if (nextcode >= 0xDC00 && nextcode <= 0xDFFF) {\n                    point = ((point - 0xD800) * 0x400) + nextcode - 0xDC00 + 0x10000;\n                    idx += 1;\n                    if (point > 0xffff) {\n                        resArr[resPos += 1] = (0x1e << 3) | (point >>> 18);\n                        resArr[resPos += 1] = (0x2 << 6) | ((point >>> 12) & 0x3f);\n                        resArr[resPos += 1] = (0x2 << 6) | ((point >>> 6) & 0x3f);\n                        resArr[resPos += 1] = (0x2 << 6) | (point & 0x3f);\n                        continue;\n                    }\n                } else {\n                    resArr[resPos += 1] = 0xef; resArr[resPos += 1] = 0xbf;\n                    resArr[resPos += 1] = 0xbd; continue;\n                }\n            }\n            if (point <= 0x007f) {\n                resArr[resPos += 1] = (0x0 << 7) | point;\n            } else if (point <= 0x07ff) {\n                resArr[resPos += 1] = (0x6 << 5) | (point >>> 6);\n                resArr[resPos += 1] = (0x2 << 6) | (point & 0x3f);\n            } else {\n                resArr[resPos += 1] = (0xe << 4) | (point >>> 12);\n                resArr[resPos += 1] = (0x2 << 6) | ((point >>> 6) & 0x3f);\n                resArr[resPos += 1] = (0x2 << 6) | (point & 0x3f);\n            }\n        }\n        // else // IE 6-9\n        resArr.length = resPos + 1; // trim off extra weight\n        return resArr;\n    }\n}\n\nexport { TextEncoder };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TextEncoder } from './TextEncoder.js';\nimport { RpcStruct } from '../rpc/RpcStruct.js';\n\nclass JsonRpcMarshaller {\n    /**\n     * Takes an RPC message and converts it\n     * into a byte array that can be added\n     * as part of the SdlPacket.\n     * @param {RpcStruct} rpcStruct - This param contains the json object to transform\n     * based on the getParameters method. This can be an RpcStruct or something like RpcMessage\n     * which extends RpcStruct.\n     * @returns {null|Uint8Array} - Either the byte array or null on error.\n     */\n    static marshall (rpcStruct) {\n        let jsonBytes = null;\n        function paramify (rpcStruct) {\n            const params = rpcStruct.getParameters();\n            for (const key in params) {\n                if (params[key] instanceof RpcStruct) {\n                    params[key] = paramify(params[key]);\n                }\n            }\n            return params;\n        }\n\n        try {\n            const jsonObject = paramify(rpcStruct);\n            const stringVersion = JSON.stringify(jsonObject);\n            jsonBytes = this._encode(stringVersion);\n        } catch (error) {\n            console.error('Failed to encode messages to JSON.', error);\n        }\n        return jsonBytes;\n    }\n\n    /**\n     * Takes a byte array and transforms it into a json object.\n     * @param {Uint8Array} bytes - Byte array containing the json string to convert.\n     * @returns {null|Object} - Either a json object or null on error in parsing.\n     */\n    static unmarshall (bytes) {\n        let ret = null;\n        try {\n            const jsonString = this._decode(bytes);\n            ret = JSON.parse(jsonString);\n        } catch (error) {\n            console.error('Failed to parse JSON', error);\n        }\n        return ret;\n    }\n\n    /**\n     * Transform a string into a byte array.\n     * @param {String} str - String to transform.\n     * @returns {Uint8Array}\n     * @private\n     */\n    static _encode (str) {\n        return new Uint8Array(TextEncoder.encode(str));\n    }\n\n    /**\n     * Transform a byte array into a string.\n     * @param {Uint8Array} bytes - Byte array to transform.\n     * @returns {String}\n     * @private\n     */\n    static _decode (bytes) {\n        return Buffer.from(bytes).toString();\n    }\n}\n\nexport { JsonRpcMarshaller };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * Contains the raw json data and bulk data for an RPC request/response along with the basic header info\n * rpc type, function id, and correlation id.\n *\n * This class can parse incoming data from sdl core and assemble a binary header to send to sdl core.\n *\n *\n *  @private {number} _rpcType - Request = 0, Response = 1, Notification = 2.\n *  @private {number} _functionId - Matches a function Id in the mobile api spec https://github.com/smartdevicelink/rpc_spec/blob/master/MOBILE_API.xml\n *  @private {number} _correlationId - For a request this id is provided and the matching response will have this same id.\n *  @private {number} _jsonSize - Size of json.\n *  @private {Uint8Array} _jsonData - Raw json data. This can be parsed using the JsonRpcMarshaller.\n *  @private {Uint8Array} _bulkData - Bulk data (optional). If something cannot be expressed as a json object it will be in the bulk data (eg PutFile/GetFile has the full file in bulk data.)\n */\nclass BinaryFrameHeader {\n    /**\n     *\n     * @param {number} rpcType\n     * @param {number} functionId\n     * @param {number} correlationId\n     * @param {number} jsonSize\n     * @constructor\n     */\n    constructor (rpcType, functionId, correlationId, jsonSize) {\n        this._rpcType = rpcType;\n        this._functionId = functionId;\n        this._correlationId = correlationId;\n        this._jsonSize = jsonSize;\n        this._bulkData = null;\n        this._jsonData = null;\n    }\n\n    /**\n     * Given a byte array with uint8 values, a BinaryFrameHeader instance is created.\n     * @param {array} binaryFrameHeaderData - Byte array containing basic information on the frames type, length, and related ids.\n     * @returns {BinaryFrameHeader}\n     */\n    static fromBinaryHeader (binaryFrameHeaderData) {\n        const rpcType = binaryFrameHeaderData[0] >> 4;\n\n        let functionId = (binaryFrameHeaderData[0] & 0x0F) << 24;\n        functionId += (binaryFrameHeaderData[1] & 0xFF) << 16;\n        functionId += (binaryFrameHeaderData[2] & 0xFF) << 8;\n        functionId += binaryFrameHeaderData[3] & 0xFF;\n\n        let correlationId = (binaryFrameHeaderData[4] & 0xFF) << 24;\n        correlationId += (binaryFrameHeaderData[5] & 0xFF) << 16;\n        correlationId += (binaryFrameHeaderData[6] & 0xFF) << 8;\n        correlationId += binaryFrameHeaderData[7] & 0xFF;\n\n        let jsonSize = (binaryFrameHeaderData[8] & 0xFF) << 24;\n        jsonSize += (binaryFrameHeaderData[9] & 0xFF) << 16;\n        jsonSize += (binaryFrameHeaderData[10] & 0xFF) << 8;\n        jsonSize += binaryFrameHeaderData[11] & 0xFF;\n\n        const binaryFrameHeader = new BinaryFrameHeader(rpcType, functionId, correlationId, jsonSize);\n\n        const jsonDataStart = BinaryFrameHeader.HEADER_SIZE;\n        const jsonDataEnd = BinaryFrameHeader.HEADER_SIZE + jsonSize;\n\n        binaryFrameHeader.setJsonData(binaryFrameHeaderData.slice(jsonDataStart, jsonDataEnd));\n\n        // any data after the JSON data is the bulk data (eg PutFile contains the file after the main json)\n        if (binaryFrameHeaderData.length > jsonDataEnd) {\n            const bulkData = binaryFrameHeaderData.slice(jsonDataEnd);\n            binaryFrameHeader.setBulkData(bulkData);\n        }\n        return binaryFrameHeader;\n    }\n\n\n    /**\n     * Assembles binary header data.\n     * @returns {array}\n     */\n    assembleHeaderBytes () {\n        const buffer = [];\n        const functionId = this._functionId;\n        const correlationId = this._correlationId;\n        const rpcType = this._rpcType;\n\n        buffer.push((functionId & 0x0F000000) >> 24) + (rpcType << 4);\n        buffer.push((functionId & 0x00FF0000) >> 16);\n        buffer.push((functionId & 0x0000FF00) >> 8);\n        buffer.push(functionId & 0x000000FF);\n\n        buffer.push((correlationId & 0xFF000000) >> 24);\n        buffer.push((correlationId & 0x00FF0000) >> 16);\n        buffer.push((correlationId & 0x0000FF00) >> 8);\n        buffer.push(correlationId & 0x000000FF);\n\n        const jsonSize = this._jsonSize;\n        buffer.push((jsonSize & 0xFF000000) >> 24);\n        buffer.push((jsonSize & 0x00FF0000) >> 16);\n        buffer.push((jsonSize & 0x0000FF00) >> 8);\n        buffer.push(jsonSize & 0x000000FF);\n\n        return buffer;\n    }\n\n    /**\n     * Sets the rpc type of the binary header.\n     * @param {number} type\n     * @returns {BinaryFrameHeader}\n     */\n    setRpcType (type) {\n        this._rpcType = type;\n        return this;\n    }\n\n    /**\n     * Gets the rpc type of the binary header\n     * @returns {number}\n     */\n    getRpcType () {\n        return this._rpcType;\n    }\n\n    /**\n     * Sets the function id of the binary header.\n     * @param {number} id\n     * @returns {BinaryFrameHeader}\n     */\n    setFunctionId (id) {\n        this._functionId = id;\n        return this;\n    }\n\n    /**\n     * Gets the function Id of the binary header.\n     * @returns {number}\n     */\n    getFunctionId () {\n        return this._functionId;\n    }\n\n    /**\n     * Sets the correlation Id of the binary header.\n     * @param {number} id\n     * @returns {BinaryFrameHeader}\n     */\n    setCorrelationId (id) {\n        this._correlationId = id;\n        return this;\n    }\n\n    /**\n     * Gets the correlation Id of the binary header.\n     */\n    getCorrelationId () {\n        return this._correlationId;\n    }\n\n    /**\n     * Sets the json size of the binary header.\n     * @param {number} size\n     * @returns {BinaryFrameHeader}\n     */\n    setJsonSize (size) {\n        this._jsonSize = size;\n        return this;\n    }\n\n    /**\n     * Gest the json size of the binary header.\n     * @returns {number}\n     */\n    getJsonSize () {\n        return this._jsonSize;\n    }\n\n    /**\n     * Returns the json data as a byte array.\n     * @returns {array} - Byte array of json data.\n     */\n    getJsonData () {\n        return this._jsonData;\n    }\n\n    /**\n     * Sets the json data of the binary header.\n     * @param {array} data - Byte array of json data\n     * @returns {BinaryFrameHeader}\n     */\n    setJsonData (data) {\n        this._jsonData = data;\n        return this;\n    }\n\n    /**\n     * Sets the bulk data of the binary header.\n     * Supported by protcol 2 and up.\n     * @param {array} data - Byte array of bulk data\n     */\n    setBulkData (data) {\n        this._bulkData = data;\n        return this;\n    }\n\n    /**\n     * Gets the bulk data of the binary header.\n     * Supported by protcol 2 and up.\n     * @returns {array} - Byte array of bulk data\n     */\n    getBulkData () {\n        return this._bulkData;\n    }\n}\n\nBinaryFrameHeader.HEADER_SIZE = 12;\n\nexport { BinaryFrameHeader };\n\n\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\nimport { FrameType } from './enums/FrameType.js';\nimport { SdlPacket } from './SdlPacket.js';\nimport { FunctionID } from './../rpc/enums/FunctionID.js';\nimport { JsonRpcMarshaller } from './../util/JsonRpcMarshaller.js';\nimport { BinaryFrameHeader } from './BinaryFrameHeader.js';\n\n\n/**\n * Takes an rpc message and converts it into packets ready to send.\n */\nclass MessageFrameDisassembler {\n    /**\n      *\n      * @param {RpcRequest} rpcRequest - RPC message that will split into smaller sdl packets.\n      * @param {Number} sessionId - sessionId for packets\n      * @param {Number} messageId - messageId for packets.\n      * @param {Number} mtu - max transport unit, used to determine packet size to send.\n      * @param {Number} version - major version\n      * @param {Boolean} isEncrypted - packet is encrypted\n      * @param {cb} packetCallback - This function will be called when a packet is ready to send.\n      * @constructor\n      */\n    constructor (rpcRequest, sessionId, messageId, mtu, version, isEncrypted, packetCallback) {\n        this._rpcRequest = rpcRequest;\n        this._sessionId = sessionId;\n        this._messageId = messageId;\n        this._isEncrypted = isEncrypted;\n\n        if (!mtu) {\n            throw new Error('MTU must be specified.');\n        }\n        this._mtu = mtu;\n\n        if (!version) {\n            throw new Error('Version must be specified.');\n        }\n        this._version = version;\n        this._packetCallback = packetCallback;\n    }\n\n    /**\n      * Immediately build rpc and respond to packetcallback with packets to send.\n      * @param {RpcRequest} rpcMessage - RPC message that will split into smaller sdl packets.\n      * @param {Number} sessionId - sessionId for packets\n      * @param {Number} messageId - messageId for packets.\n      * @param {Number} mtu - max transport unit, used to determine packet size to send.\n      * @param {Number} version - major version\n      * @param {Boolean} isEncrypted - packet is encrypted\n      * @param {cb} packetCallback - This function will be called when a packet is ready to send.\n      */\n    static buildRPC (rpcRequest, sessionId, messageId, mtu, version, isEncrypted, cb) {\n        const obj = new MessageFrameDisassembler(rpcRequest, sessionId, messageId, mtu, version, isEncrypted, cb);\n        obj._doRequest();\n        return obj;\n    }\n\n\n    /**\n     * Constructs the main BinaryFrameHeader buffer.\n     * @returns {Unit8Array}\n     */\n    _buildRPCMainBuffer () {\n        const rpcBulkData = this._rpcRequest.getBulkData();\n        const correlationId = this._rpcRequest.getCorrelationId();\n        const rpcType =  this._rpcRequest.getRPCType();\n\n        const functionName = this._rpcRequest.getFunctionName();\n        const functionId = FunctionID.valueForKey(functionName);\n        if (!functionId) {\n            throw new Error(`Failed to find function ${functionName}`);\n        }\n\n        const jsonBuffer = JsonRpcMarshaller.marshall(this._rpcRequest);\n        const jsonSize = jsonBuffer.length;\n\n        const bfh = new BinaryFrameHeader(rpcType, functionId, correlationId);\n        bfh.setJsonData(jsonBuffer);\n        bfh.setJsonSize(jsonSize);\n        bfh.setBulkData(rpcBulkData);\n        const headerSize = 12;\n        const bulkData = bfh.getBulkData();\n        let bulkDataSize = 0;\n        if (bulkData) {\n            bulkDataSize = bulkData.length;\n        }\n        const totalMessageSize = headerSize + jsonSize + bulkDataSize;\n        const data = new Uint8Array(totalMessageSize);\n        data.set(bfh.assembleHeaderBytes(), 0);\n        data.set(jsonBuffer, headerSize);\n        if (bulkData) {\n            data.set(bulkData, headerSize + jsonSize);\n        }\n        return data;\n    }\n\n\n    /**\n     * Start the RPC request and use callback to send\n     * sdl packets of the appropriate size.\n     * @private\n     */\n    _doRequest () {\n        const version = this._version;\n        const frameInfo = 0;\n        const frameType = FrameType.SINGLE;\n\n        const serviceType = SdlPacket.SERVICE_TYPE_RPC;\n        const sessionId = this._sessionId;\n        const messageId = this._messageId;\n\n        const isEncrypted = this._isEncrypted;\n        const mainBuffer = this._buildRPCMainBuffer();\n        const mtu = this._mtu;\n\n        const frameCount = Math.ceil(mainBuffer.length / mtu);\n\n        if (frameCount <= 1) {\n            const fullPacket = this._constructPacket(\n                version,\n                serviceType,\n                frameInfo,\n                sessionId,\n                messageId,\n                frameType,\n                mainBuffer,\n                isEncrypted\n            );\n            this._packetCallback(fullPacket);\n        } else {\n            const buffer = new ArrayBuffer(8); // Int32 has 8 bytes\n            const view = new DataView(buffer);\n            view.setUint32(0, mainBuffer.length, false);\n            view.setUint32(4, frameCount, false);\n            const payload = new Uint8Array(buffer);\n\n            const firstHeader = this._constructPacket(version, serviceType, frameInfo, sessionId, messageId, FrameType.FIRST, payload, isEncrypted);\n            this._packetCallback(firstHeader);\n\n            this._buildConsecutiveFrames(\n                version,\n                serviceType,\n                sessionId,\n                messageId,\n                mainBuffer,\n                mtu,\n                isEncrypted\n            );\n        }\n    }\n\n\n    /**\n     * Creates an sdl packet.\n     * @param {Number} version\n     * @param {ServiceType} serviceType\n     * @param {Number} frameInfo\n     * @param {Number} sessionId\n     * @param {Number} messageId\n     * @param {Number} frameType\n     * @param {Unit8Array} payload\n     * @param {Boolean} isEncrypted\n     * @returns {SdlPacket}\n     */\n    _constructPacket (version, serviceType, frameInfo, sessionId, messageId, frameType, payload, isEncrypted) {\n        const dataSize = payload.length;\n        const offset = 0;\n        const bytesToWrite = dataSize;\n        const sdlPacket = new SdlPacket(version, isEncrypted, frameType, serviceType, frameInfo, sessionId, dataSize, messageId, payload, offset, bytesToWrite);\n        return sdlPacket;\n    }\n\n\n    /**\n     * Builds consecutive frames after the inital frame is sent for a multi-frame message.\n     * @param {Number} version\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {Number} messageId\n     * @param {Buffer} buffer\n     * @param {Number} length\n     * @param {Boolean} isEncrypted\n     */\n    _buildConsecutiveFrames (version, serviceType, sessionId, messageId, buffer, length, isEncrypted) {\n        let frameSequenceNumber;\n        let count = 0;\n        let offset = 0;\n\n        while (frameSequenceNumber !== 0) {\n            if (offset + length >= buffer.length) {\n                frameSequenceNumber = 0; // last frame\n            } else {\n                frameSequenceNumber = (count % 255) + 1; // 1,2,3,...,255,1\n            }\n\n            const header = this._constructPacket(\n                version,\n                serviceType,\n                frameSequenceNumber,\n                sessionId,\n                messageId,\n                FrameType.CONSECUTIVE,\n                buffer.slice(offset, offset + length),\n                isEncrypted\n            );\n            this._packetCallback(header);\n            count++;\n            offset += length;\n        }\n    }\n}\n\n\n\nexport { MessageFrameDisassembler };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass TransportListener {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this._onTransportConnected = null;\n        this._onTransportDisconnected = null;\n        this._onError = null;\n        this._onPacketReceived = null;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnTransportConnected (func) {\n        this._onTransportConnected = func;\n\n        return this;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnTransportDisconnected (func) {\n        this._onTransportDisconnected = func;\n\n        return this;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnError (func) {\n        this._onError = func;\n\n        return this;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnPacketReceived (func) {\n        this._onPacketReceived = func;\n\n        return this;\n    }\n\n\n    onTransportConnected () {\n        if (typeof this._onTransportConnected === 'function') {\n            this._onTransportConnected();\n        }\n    }\n\n    onTransportDisconnected () {\n        if (typeof this._onTransportDisconnected === 'function') {\n            this._onTransportDisconnected();\n        }\n    }\n\n    onError (error = null) {\n        if (typeof this._onError === 'function') {\n            this._onError(error);\n        }\n    }\n\n    onPacketReceived (sdlPacket) {\n        if (typeof this._onPacketReceived === 'function') {\n            this._onPacketReceived(sdlPacket);\n        }\n    }\n}\n\nexport { TransportListener };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass Version {\n    /**\n    * @constructor\n    */\n    constructor (major, minor, patch) {\n        this.setMajor(major);\n        this.setMinor(minor);\n        this.setPatch(patch);\n    }\n\n    /**\n    * @param {Number} major\n    * @return {Version}\n    */\n    setMajor (major) {\n        this._major = parseInt(major) || 0;\n\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getMajor () {\n        return this._major;\n    }\n\n    /**\n    * @param {Number} minor\n    * @return {Version}\n    */\n    setMinor (minor) {\n        this._minor = parseInt(minor) || 0;\n\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getMinor () {\n        return this._minor;\n    }\n\n    /**\n    * @param {Number} patch\n    * @return {Version}\n    */\n    setPatch (patch) {\n        this._patch = parseInt(patch) || 0;\n\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getPatch () {\n        return this._patch;\n    }\n\n    /**\n    * @param {String} version - Parse this string to a Version object\n    * @return {Version}\n    */\n    fromString (version) {\n        const versions = version.split('.');\n        if (versions.length !== 3) {\n            throw new Error('Incorrect version string format');\n        }\n        this.setMajor(versions[0]);\n        this.setMinor(versions[1]);\n        this.setPatch(versions[2]);\n\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    toString () {\n        return `${this.getMajor()}.${this.getMinor()}.${this.getPatch()}`;\n    }\n\n    /**\n    * Method to test if this instance of Version is newer than the supplied one.\n    * @param version - the version to check against\n    * @return {Number} - 1 if this instance is newer, -1 if supplied version is newer, and 0 if they are equal\n    */\n    isNewerThan (version) {\n        if (this.getMajor() > version.getMajor()) {\n            return 1;\n        } else if (this.getMajor() === version.getMajor()) {\n            if (this.getMinor() > version.getMinor()) {\n                return 1;\n            } else if (this.getMinor() === version.getMinor()) {\n                if (this.getPatch() > version.getPatch()) {\n                    return 1;\n                } else if (this.getPatch() === version.getPatch()) {\n                    return 0;\n                }\n            }\n        }\n        return -1;\n    }\n}\n\nexport { Version };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ServiceType\n * @property {Object} _MAP\n */\nclass ServiceType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CONTROL () {\n        return ServiceType._MAP.CONTROL;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get RPC () {\n        return ServiceType._MAP.RPC;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get AUDIO () {\n        return ServiceType._MAP.AUDIO;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get VIDEO () {\n        return ServiceType._MAP.VIDEO;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get HYBRID () {\n        return ServiceType._MAP.HYBRID;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return ServiceType._valueForKey(key, ServiceType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return ServiceType._keyForValue(value, ServiceType._MAP);\n    }\n}\n\nServiceType._MAP = Object.freeze({\n    'CONTROL': 0x00,\n    'RPC': 0x07,\n    'AUDIO': 0x0A,\n    'VIDEO': 0x0B,\n    'HYBRID':0x0F,\n});\n\nexport { ServiceType };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FrameType } from './enums/FrameType.js';\nimport { SdlPacket } from './SdlPacket.js';\n\n/**\n * Callback for finished packet.\n * @callback cb\n * @param {string} error - If there is an error that cannot be recovered from it will be returned.\n * @param {SdlPacket} sdlPacket - Finished sdl packet.\n */\n\n/**\n * Assembles sdl packets which may come in seperate chunks if the data exceeds the\n * max transport unit allowed by sdl core.\n *\n * @private {cb} _callback - Callback for combined packet.\n * @private {number} _totalConsecutiveFrames - Total consecutive frames expected for a multiframe packet.\n * @private {number} _consecutiveFramesDataLength - Expected data length of finished multiframe packet.\n * @private {number} _consecutiveFramesHandledCount - Running total of consecutive frames received and handled.\n * @private {array} _accumulator Combines incoming bytes from consecutive frames.\n */\nclass MessageFrameAssembler {\n    /**\n    * @constructor\n    * @param {cb} callback\n    */\n    constructor (callback) {\n        if (typeof callback !== 'function') {\n            throw new Error('Callback not of expected type (function) for MessageFrameAssembler');\n        }\n\n        this._callback = callback;\n\n        this._accumulator = [];\n        this._totalConsecutiveFrames = 0;\n        this._consecutiveFramesHandledCount = 0;\n        this._consecutiveFramesDataLength = 0;\n    }\n\n    /**\n     * Accepts a single frame or multiframe packet. The callback is used when the packet\n     * is completely read. For a single frame this is immediately. For a multi frame packet\n     * @param {SdlPacket} sdlPacket - Incoming sdl packet to be read.\n    */\n    handleFrame (sdlPacket) {\n        const frameType = sdlPacket.getFrameType();\n        // If the sdl packet is a single frame nothing needs to be assembled and this can be returned immediately.\n        if (frameType !== FrameType.FIRST && frameType !== FrameType.CONSECUTIVE) {\n            return this._callback(null, sdlPacket);\n        }\n        return this._handleMultiFrameMessage(sdlPacket);\n    }\n\n    /**\n     * Handles the first data frame. Sets the expected frame count and data length.\n     * @param {SdlPacket} sdlPacket\n     * @private\n     */\n    _handleFirstDataFrame (sdlPacket) {\n        /** @type {array} Array of uint8 */\n        const payload = sdlPacket.getPayload();\n\n        if (payload instanceof Uint8Array !== true || payload.length !== 8) {\n            throw new Error('Error handling first frame. Payload is an invalid length should be length 8.');\n        }\n        for (const byte in payload) {\n            if (byte < 0x00 || byte > 0xFF) {\n                throw new Error('Invalid payload. Must be an array of uint8 bytes.');\n            }\n        }\n\n        // first 4 8-bit integers contain the data length.\n        let dataLength = (payload[0] & 0x0F) << 24; // 8-bit x 3\n        dataLength += (payload[1] & 0xFF) << 16; // 8 x 2\n        dataLength += (payload[2] & 0xFF) << 8; // 8 x 1\n        dataLength += payload[3] & 0xFF; // 8 x 0\n\n        let frameCount = (payload[4] & 0xFF) << 24;\n        frameCount += (payload[5] & 0xFF) << 16;\n        frameCount += (payload[6] & 0xFF) << 8;\n        frameCount += payload[7] & 0xFF;\n\n        this._totalConsecutiveFrames = frameCount;\n        this._consecutiveFramesDataLength = dataLength;\n    }\n\n    /**\n     * First frame should be read in before this is called. Once the last\n     * frame is read, callback is used.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleConsecutiveFrame (sdlPacket) {\n        this._consecutiveFramesHandledCount++;\n\n        const frameType = sdlPacket.getFrameType();\n        /**\n         * frameSequence nth frame, or 0 for last frame,\n         * 8 bits are used to store this info so the count reverts to 1 after 255\n         * This doesn't affect reading the packet but it is notable if frame sequence is relied on.\n         */\n        const frameSequence = sdlPacket.getFrameInfo();\n\n        const payload = sdlPacket.getPayload();\n\n        for (const byte of payload) {\n            this._accumulator.push(byte);\n        }\n\n        // This is the last frame, finish things up and use callback.\n        if (frameSequence === 0) {\n            if (this._consecutiveFramesHandledCount !== this._totalConsecutiveFrames) {\n                console.warn(`Total frames expected ${this._totalConsecutiveFrames} does not match total frames received ${this._consecutiveFramesHandledCount}`);\n            }\n\n            if (this._consecutiveFramesDataLength !== this._accumulator.length) {\n                console.warn(`Total data expected ${this._consecutiveFramesDataLength} does not match total data received ${this._accumulator.length}`);\n            }\n\n            const finishedSdlPacket = new SdlPacket(\n                sdlPacket.getVersion(),\n                sdlPacket.getEncryption(),\n                frameType,\n                sdlPacket.getServiceType(),\n                frameSequence,\n                sdlPacket.getSessionID(),\n                this._accumulator.length,\n                sdlPacket.getMessageID(),\n                this._accumulator,\n                0, // no offset\n                this._accumulator.length // read the entire buffer\n            );\n\n            this._callback(null, finishedSdlPacket);\n        }\n    }\n\n    /**\n     * Handle the sdl packet based on its frame type, FIRST or CONSECUTIVE.\n     * Callback is used when final packet is read.\n     * @param {SdlPacket} sdlPacket - Sdl packet to be read.\n     */\n    _handleMultiFrameMessage (sdlPacket) {\n        const frameType = sdlPacket.getFrameType();\n        if (frameType === FrameType.FIRST) {\n            return this._handleFirstDataFrame(sdlPacket);\n        } else { // FrameType.Consecutive\n            return this._handleConsecutiveFrame(sdlPacket);\n        }\n    }\n}\n\n\n\nexport { MessageFrameAssembler };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass ControlFrameTags {\n}\n\n// hidden inner objects\n\nconst StartServiceACKBase = {\n    MTU: 'mtu',\n};\n\nconst NAKBase = {\n    REJECTED_PARAMS: 'rejectedParams',\n};\n\nconst StartServiceProtocolVersion = {\n    /** The negotiated version of the protocol. Must be in the format \"Major.Minor.Patch\"*/\n    PROTOCOL_VERSION: 'protocolVersion',\n};\n\nconst StartServiceHashId = {\n    /** Hash ID to identify this service and used when sending an EndService control frame*/\n    HASH_ID: 'hashId',\n};\n\nconst StartServiceDimensions = {\n    HEIGHT: 'height',\n    WIDTH: 'width',\n};\n\n// static members\n\nControlFrameTags.RPC = Object.freeze({\n    StartService: StartServiceProtocolVersion,\n\n    StartServiceACK: Object.assign({\n        /** HU allowed transport for secondary connection */\n        SECONDARY_TRANSPORTS: 'secondaryTransports',\n        /** HU allowed transports for audio and video services (1 == Primary, 2 == Secondary) */\n        AUDIO_SERVICE_TRANSPORTS: 'audioServiceTransports',\n        VIDEO_SERVICE_TRANSPORTS: 'videoServiceTransports',\n        /** Auth token to be used for log in into services **/\n        AUTH_TOKEN: 'authToken',\n    }, StartServiceACKBase, StartServiceProtocolVersion, StartServiceHashId),\n\n    StartServiceNAK: NAKBase,\n\n    EndService: StartServiceHashId,\n\n    EndServiceACK: {},\n\n    EndServiceNAK: NAKBase,\n\n    TransportEventUpdate: {\n        TCP_IP_ADDRESS: 'tcpIpAddress',\n        TCP_PORT: 'tcpPort',\n    },\n\n    RegisterSecondaryTransport: {},\n\n    RegisterSecondaryTransportACK: {},\n\n    RegisterSecondaryTransportNAK: Object.assign({\n        REASON: 'reason',\n    }, NAKBase),\n});\n\nControlFrameTags.Audio = Object.freeze({\n    StartService: {},\n\n    StartServiceACK: StartServiceACKBase,\n\n    StartServiceNAK: NAKBase,\n\n    EndService: {},\n\n    EndServiceACK: {},\n\n    EndServiceNAK: NAKBase,\n});\n\nControlFrameTags.Video = Object.freeze({\n    StartService: Object.assign({\n        VIDEO_PROTOCOL: 'videoProtocol',\n        VIDEO_CODEC: 'videoCodec',\n    }, StartServiceDimensions),\n\n    StartServiceACK: Object.assign({\n        VIDEO_PROTOCOL: 'videoProtocol',\n        VIDEO_CODEC: 'videoCodec',\n    }, StartServiceACKBase, StartServiceDimensions),\n\n    StartServiceNAK: NAKBase,\n\n    EndService: {},\n\n    EndServiceACK: {},\n\n    EndServiceNAK: NAKBase,\n});\n\nexport { ControlFrameTags };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass BitConverter {\n    /**\n\t * @param {ArrayBuffer} buffer - buffer that will be converted to int\n     * @param {Number} offset - int optional, the offset shift\n\t * @return {Number} int converted from buffer or -1 if buffer is null\n\t */\n    static arrayBufferToInt32 (buffer, offset = 0) {\n        if (!buffer) {\n            return -1;\n        }\n        const view = new DataView(buffer);\n        return view.getUint32(offset);\n    }\n\n    /**\n\t * @param {Number} value - the integer to be converted\n\t * @return {ArrayBuffer} buffer converted from input value\n\t */\n    static int32ToArrayBuffer (value) {\n        const buffer = new ArrayBuffer(4); // Int32 has 4 bytes\n        const view = new DataView(buffer);\n        view.setUint32(0, value, false);\n        return buffer;\n    }\n}\n\nexport { BitConverter };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SdlPacket } from './SdlPacket.js';\nimport { ControlFrameTags } from './enums/ControlFrameTags.js';\nimport { BitConverter } from './../util/BitConverter.js';\nimport { FrameType } from './enums/FrameType.js';\n\n/**\n * Creates control packets.\n * For regular RPC RPCMessage should be used.\n */\nclass SdlPacketFactory {\n    /**\n     * Creates a heartbeat acknowlegement packet.\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID\n     * @param {Number} version\n     * @returns {SdlPacket}\n     */\n    static createHeartbeatACK (serviceType, sessionID, version) {\n        return new SdlPacket(version, false, FrameType.CONTROL,\n            serviceType, SdlPacket.FRAME_INFO_HEART_BEAT_ACK, sessionID,\n            0, 0, null);\n    }\n\n    /**\n     * Creates an end session packet.\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID\n     * @param {Number} messageID\n     * @param {Number} version\n     * @param {Number} hashID\n     */\n    static createEndSession (serviceType, sessionID, messageID, version, hashID) {\n        if (version < 5) {\n            const payload = new Uint8Array(BitConverter.int32ToArrayBuffer(hashID));\n            return new SdlPacket(version, false, FrameType.CONTROL,\n                serviceType, SdlPacket.FRAME_INFO_END_SERVICE, sessionID,\n                payload.length, messageID, payload, 0, payload.length);\n        } else {\n            const endSession = new SdlPacket(version, false, FrameType.CONTROL,\n                serviceType, SdlPacket.FRAME_INFO_END_SERVICE, sessionID,\n                0, messageID, null);\n            endSession.putTag(ControlFrameTags.RPC.EndService.HASH_ID, hashID);\n            return endSession;\n        }\n    }\n}\n\nexport { SdlPacketFactory };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ImageType\n * @property {Object} _MAP\n */\nclass ImageType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get STATIC () {\n        return ImageType._MAP.STATIC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DYNAMIC () {\n        return ImageType._MAP.DYNAMIC;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return ImageType._valueForKey(key, ImageType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return ImageType._keyForValue(value, ImageType._MAP);\n    }\n}\n\nImageType._MAP = Object.freeze({\n    'STATIC': 'STATIC',\n    'DYNAMIC': 'DYNAMIC',\n});\n\nexport { ImageType };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ImageType } from '../enums/ImageType.js';\n\nclass Image extends RpcStruct {\n    /**\n    * @constructor\n    */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {String} value\n    * @return {Image}\n    */\n    setValue (value) {\n        this.setParameter(Image.KEY_VALUE, value);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getValue () {\n        return this.getParameter(Image.KEY_VALUE);\n    }\n\n    /**\n    * @param {ImageType} type\n    * @return {Image}\n    */\n    setImageType (type) {\n        this.validateType(ImageType, type);\n\n        this.setParameter(Image.KEY_IMAGE_TYPE, type);\n        return this;\n    }\n\n    /**\n    * @return {ImageType}\n    */\n    getImageType () {\n        return this.getObject(ImageType, Image.KEY_IMAGE_TYPE);\n    }\n\n    /**\n    * @param {Boolean} isTemplate\n    * @return {Image}\n    */\n    setIsTemplate (isTemplate) {\n        this.setParameter(Image.KEY_IS_TEMPLATE, isTemplate);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getIsTemplate () {\n        return this.getParameter(Image.KEY_IS_TEMPLATE);\n    }\n}\n\nImage.KEY_VALUE = 'value';\nImage.KEY_IMAGE_TYPE = 'imageType';\nImage.KEY_IS_TEMPLATE = 'isTemplate';\n\nexport { Image };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass MenuParams extends RpcStruct {\n    /**\n    * @constructor\n    */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Number} id\n    * @return {MenuParams}\n    */\n    setParentID (id) {\n        this.setParameter(MenuParams.KEY_PARENT_ID, id);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getParentID () {\n        return this.getParameter(MenuParams.KEY_PARENT_ID);\n    }\n\n    /**\n    * @param {Number} position\n    * @return {MenuParams}\n    */\n    setPosition (position) {\n        this.setParameter(MenuParams.KEY_POSITION, position);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getPosition () {\n        return this.getParameter(MenuParams.KEY_POSITION);\n    }\n\n    /**\n    * @param {String} menuName\n    * @return {MenuParams}\n    */\n    setMenuName (menuName) {\n        this.setParameter(MenuParams.KEY_MENU_NAME, menuName);\n        return this;\n    }\n\n    /**\n    * @param {String}\n    */\n    getMenuName () {\n        return this.getParameter(MenuParams.KEY_MENU_NAME);\n    }\n}\n\nMenuParams.KEY_PARENT_ID = 'parentID';\nMenuParams.KEY_POSITION  = 'position';\nMenuParams.KEY_MENU_NAME = 'menuName';\n\nexport { MenuParams };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { Image } from '../structs/Image.js';\nimport { MenuParams } from '../structs/MenuParams.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass AddCommand extends RpcRequest {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AddCommand);\n    }\n\n\n    /**\n    * @param {Number} id\n    * @return {AddCommand}\n    */\n    setCmdID (id) {\n        this.setParameter(AddCommand.KEY_CMD_ID, id);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getCmdID () {\n        return this.getParameter(AddCommand.KEY_CMD_ID);\n    }\n\n    /**\n    * @param {MenuParams} menuParams\n    * @return {AddCommand}\n    */\n    setMenuParams (menuParams) {\n        this.validateType(MenuParams, menuParams);\n\n        this.setParameter(AddCommand.KEY_MENU_PARAMS, menuParams);\n        return this;\n    }\n\n    /**\n    * @return {MenuParams}\n    */\n    getMenuParams () {\n        return this.getObject(MenuParams, AddCommand.KEY_MENU_PARAMS);\n    }\n\n    /**\n    * @param {Array<String>} vrCommands\n    * @return {AddCommand}\n    */\n    setVrCommands (vrCommands) {\n        this.setParameter(AddCommand.KEY_VR_COMMANDS, vrCommands);\n        return this;\n    }\n\n    /**\n    * @return {Array<String>}\n    */\n    getVrCommands () {\n        return this.getParameter(AddCommand.KEY_VR_COMMANDS);\n    }\n\n    /**\n    * @param {Image} icon\n    * @return {AddCommand}\n    */\n    setCmdIcon (icon) {\n        this.validateType(Image, icon);\n\n        this.setParameter(AddCommand.KEY_CMD_ICON, icon);\n        return this;\n    }\n\n    /**\n    * @return {Image}\n    */\n    getCmdIcon () {\n        return this.getObject(Image, AddCommand.KEY_CMD_ICON);\n    }\n}\n\nAddCommand.KEY_CMD_ICON = 'cmdIcon';\nAddCommand.KEY_MENU_PARAMS = 'menuParams';\nAddCommand.KEY_CMD_ID = 'cmdID';\nAddCommand.KEY_VR_COMMANDS = 'vrCommands';\n\nexport { AddCommand };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcResponse } from '../RpcResponse.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass AddCommandResponse extends RpcResponse {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AddCommand);\n    }\n}\n\nexport { AddCommandResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcMessage } from './RpcMessage.js';\nimport { RpcType } from './enums/RpcType.js';\n\nclass RpcNotification extends RpcMessage {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setRPCType(RpcType.NOTIFICATION);\n    }\n}\n\nexport { RpcNotification };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} HMILevel\n * @property {Object} _MAP\n */\nclass HMILevel extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_FULL () {\n        return HMILevel._MAP.HMI_FULL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_LIMITED () {\n        return HMILevel._MAP.HMI_LIMITED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_BACKGROUND () {\n        return HMILevel._MAP.HMI_BACKGROUND;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_NONE () {\n        return HMILevel._MAP.HMI_NONE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return HMILevel._valueForKey(key, HMILevel._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return HMILevel._keyForValue(value, HMILevel._MAP);\n    }\n}\n\nHMILevel._MAP = Object.freeze({\n    'HMI_FULL': 'FULL',\n    'HMI_LIMITED': 'LIMITED',\n    'HMI_BACKGROUND': 'BACKGROUND',\n    'HMI_NONE': 'NONE',\n\n});\n\nexport { HMILevel };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} AudioStreamingState\n * @property {Object} _MAP\n */\nclass AudioStreamingState extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIBLE () {\n        return AudioStreamingState._MAP.AUDIBLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ATTENUATED () {\n        return AudioStreamingState._MAP.ATTENUATED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NOT_AUDIBLE () {\n        return AudioStreamingState._MAP.NOT_AUDIBLE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return AudioStreamingState._valueForKey(key, AudioStreamingState._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return AudioStreamingState._keyForValue(value, AudioStreamingState._MAP);\n    }\n}\n\nAudioStreamingState._MAP = Object.freeze({\n    'AUDIBLE': 'AUDIBLE',\n    'ATTENUATED': 'ATTENUATED',\n    'NOT_AUDIBLE': 'NOT_AUDIBLE',\n\n});\n\nexport { AudioStreamingState };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} VideoStreamingState\n * @property {Object} _MAP\n */\nclass VideoStreamingState extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get STREAMABLE () {\n        return VideoStreamingState._MAP.STREAMABLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NOT_STREAMABLE () {\n        return VideoStreamingState._MAP.NOT_STREAMABLE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return VideoStreamingState._valueForKey(key, VideoStreamingState._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return VideoStreamingState._keyForValue(value, VideoStreamingState._MAP);\n    }\n}\n\nVideoStreamingState._MAP = Object.freeze({\n    'STREAMABLE': 'STREAMABLE',\n    'NOT_STREAMABLE': 'NOT_STREAMABLE',\n\n});\n\nexport { VideoStreamingState };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} SystemContext\n * @property {Object} _MAP\n */\nclass SystemContext extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SYSCTXT_MAIN () {\n        return SystemContext._MAP.SYSCTXT_MAIN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SYSCTXT_VRSESSION () {\n        return SystemContext._MAP.SYSCTXT_VRSESSION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SYSCTXT_MENU () {\n        return SystemContext._MAP.SYSCTXT_MENU;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SYSCTXT_HMI_OBSCURED () {\n        return SystemContext._MAP.SYSCTXT_HMI_OBSCURED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SYSCTXT_ALERT () {\n        return SystemContext._MAP.SYSCTXT_ALERT;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return SystemContext._valueForKey(key, SystemContext._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return SystemContext._keyForValue(value, SystemContext._MAP);\n    }\n}\n\nSystemContext._MAP = Object.freeze({\n    'SYSCTXT_MAIN': 'MAIN',\n    'SYSCTXT_VRSESSION': 'VRSESSION',\n    'SYSCTXT_MENU': 'MENU',\n    'SYSCTXT_HMI_OBSCURED': 'HMI_OBSCURED',\n    'SYSCTXT_ALERT': 'ALERT',\n\n});\n\nexport { SystemContext };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcNotification } from '../RpcNotification.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { HMILevel } from '../enums/HMILevel.js';\nimport { AudioStreamingState } from '../enums/AudioStreamingState.js';\nimport { VideoStreamingState } from '../enums/VideoStreamingState.js';\nimport { SystemContext } from '../enums/SystemContext.js';\n\nclass OnHmiStatus extends RpcNotification {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnHMIStatus);\n    }\n\n    /**\n    * @param {HMILevel} hmiLevel\n    * @return {OnHmiStatus}\n    */\n    setHMILevel (hmiLevel) {\n        this.validateType(HMILevel, hmiLevel);\n\n        this.setParameter(OnHmiStatus.KEY_HMI_LEVEL, hmiLevel);\n        return this;\n    }\n\n    /**\n    * @return {HMILevel}\n    */\n    getHMILevel () {\n        return this.getObject(HMILevel, OnHmiStatus.KEY_HMI_LEVEL);\n    }\n\n    /**\n    * @param {AudioStreamingState} audioStreamingState\n    * @return {OnHmiStatus}\n    */\n    setAudioStreamingState (audioStreamingState) {\n        this.validateType(AudioStreamingState, audioStreamingState);\n\n        this.setParameter(OnHmiStatus.KEY_AUDIO_STREAMING_STATE, audioStreamingState);\n        return this;\n    }\n\n    /**\n    * @return {AudioStreamingState}\n    */\n    getAudioStreamingState () {\n        return this.getObject(AudioStreamingState, OnHmiStatus.KEY_AUDIO_STREAMING_STATE);\n    }\n\n    /**\n    * @param {SystemContext} systemContext\n    * @return {OnHmiStatus}\n    */\n    setSystemContext (systemContext) {\n        this.validateType(SystemContext, systemContext);\n\n        this.setParameter(OnHmiStatus.KEY_SYSTEM_CONTEXT, systemContext);\n        return this;\n    }\n\n    /**\n    * @return {SystemContext}\n    */\n    getSystemContext () {\n        return this.getObject(SystemContext, OnHmiStatus.KEY_SYSTEM_CONTEXT);\n    }\n\n    /**\n    * @param {VideoStreamingState} videoStreamingState\n    * @return {OnHmiStatus}\n    */\n    setVideoStreamingState (videoStreamingState) {\n        this.validateType(VideoStreamingState, videoStreamingState);\n\n        this.setParameter(OnHmiStatus.KEY_VIDEO_STREAMING_STATE, videoStreamingState);\n        return this;\n    }\n\n    /**\n    * @return {VideoStreamingState}\n    */\n    getVideoStreamingState () {\n        return this.getObject(VideoStreamingState, OnHmiStatus.KEY_VIDEO_STREAMING_STATE);\n    }\n\n    /**\n    * @param {Number} windowID\n    * @return {Show}\n    */\n    setWindowID (windowID) {\n        this.setParameter(OnHmiStatus.KEY_WINDOW_ID, windowID);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getWindowID () {\n        return this.getParameter(OnHmiStatus.KEY_WINDOW_ID);\n    }\n}\n\nOnHmiStatus.KEY_HMI_LEVEL = 'hmiLevel';\nOnHmiStatus.KEY_AUDIO_STREAMING_STATE = 'audioStreamingState';\nOnHmiStatus.KEY_SYSTEM_CONTEXT = 'systemContext';\nOnHmiStatus.KEY_VIDEO_STREAMING_STATE = 'videoStreamingState';\nOnHmiStatus.KEY_WINDOW_ID = 'windowID';\n\nexport { OnHmiStatus };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcNotification } from '../RpcNotification.js';\nimport { Language } from '../enums/Language.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass OnLanguageChange extends RpcNotification {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnLanguageChange);\n    }\n\n    /**\n    * @param {Language} language\n    * @return {OnLanguageChange}\n    */\n    setLanguage (language) {\n        this.validateType(Language, language);\n\n        this.setParameter(OnLanguageChange.KEY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getLanguage () {\n        return this.getObject(Language, OnLanguageChange.KEY_LANGUAGE);\n    }\n\n    /**\n    * @param {Language} language\n    * @return {OnLanguageChange}\n    */\n    setHMIDisplayLanguage (language) {\n        this.validateType(Language, language);\n\n        this.setParameter(OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getHMIDisplayLanguage () {\n        return this.getObject(Language, OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE);\n    }\n}\n\nOnLanguageChange.KEY_LANGUAGE = 'language';\nOnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage';\n\nexport { OnLanguageChange };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} FileType\n * @property {Object} _MAP\n */\nclass FileType extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GRAPHIC_BMP () {\n        return FileType._MAP.GRAPHIC_BMP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GRAPHIC_JPEG () {\n        return FileType._MAP.GRAPHIC_JPEG;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GRAPHIC_PNG () {\n        return FileType._MAP.GRAPHIC_PNG;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIO_WAVE () {\n        return FileType._MAP.AUDIO_WAVE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIO_AAC () {\n        return FileType._MAP.AUDIO_AAC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BINARY () {\n        return FileType._MAP.BINARY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get JSON () {\n        return FileType._MAP.JSON;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return FileType._valueForKey(key, FileType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return FileType._keyForValue(value, FileType._MAP);\n    }\n}\n\nFileType._MAP = Object.freeze({\n    'GRAPHIC_BMP': 'GRAPHIC_BMP',\n    'GRAPHIC_JPEG': 'GRAPHIC_JPEG',\n    'GRAPHIC_PNG': 'GRAPHIC_PNG',\n    'AUDIO_WAVE': 'AUDIO_WAVE',\n    'AUDIO_MP3': 'AUDIO_MP3',\n    'AUDIO_AAC': 'AUDIO_AAC',\n    'BINARY': 'BINARY',\n    'JSON': 'JSON',\n\n});\n\nexport { FileType };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FileType } from '../enums/FileType.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass PutFile extends RpcRequest {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PutFile);\n    }\n\n    // ------ Not part of the RPC spec itself -----\n\n    /**\n    * @param {Uint8Array} fileData\n    * @return {PutFile}\n    */\n    setFileData (fileData) {\n        this.setBulkData(fileData);\n        return this;\n    }\n    /**\n    * @return {Uint8Array}\n    */\n    getFileData () {\n        return this.getBulkData();\n    }\n\n    // ----------------- END -----------------------\n\n\n    /**\n    * @param {String} fileName\n    * @return {PutFile}\n    */\n    setFileName (fileName) {\n        this.setParameter(PutFile.KEY_FILE_NAME, fileName);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getFileName () {\n        return this.getParameter(PutFile.KEY_FILE_NAME);\n    }\n\n    /**\n    * @param {FileType} fileType\n    * @return {PutFile}\n    */\n    setFileType (fileType) {\n        this.validateType(FileType, fileType);\n        this.setParameter(PutFile.KEY_FILE_TYPE, fileType);\n        return this;\n    }\n\n    /**\n    * @return {FileType}\n    */\n    getFileType () {\n        return this.getObject(FileType, PutFile.KEY_MENU_PARAMS);\n    }\n\n    /**\n    * @param {Boolean} persistentFile\n    * @return {PutFile}\n    */\n    setPersistentFile (persistentFile) {\n        this.setParameter(PutFile.KEY_PERSISTENT_FILE, persistentFile);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getPersistentFile () {\n        return this.getParameter(PutFile.KEY_PERSISTENT_FILE);\n    }\n\n    /**\n    * @param {Boolean} systemFile\n    * @return {PutFile}\n    */\n    setSystemFile (systemFile) {\n        this.setParameter(PutFile.KEY_SYSTEM_FILE, systemFile);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getSystemFile () {\n        return this.getParameter(PutFile.KEY_SYSTEM_FILE);\n    }\n\n    /**\n    * @param {Number} offset\n    * @return {PutFile}\n    */\n    setOffset (offset) {\n        this.setParameter(PutFile.KEY_OFFSET, offset);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getOffset () {\n        return this.getParameter(PutFile.KEY_OFFSET);\n    }\n\n    /**\n    * @param {Number} length\n    * @return {PutFile}\n    */\n    setLength (length) {\n        this.setParameter(PutFile.KEY_LENGTH, length);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getLength () {\n        return this.getParameter(PutFile.KEY_LENGTH);\n    }\n\n    /**\n    * @param {Number} crc\n    * @return {PutFile}\n    */\n    setCRC (crc) {\n        this.setParameter(PutFile.KEY_CRC, crc);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getCRC () {\n        return this.getParameter(PutFile.KEY_CRC);\n    }\n}\n\nPutFile.KEY_FILE_NAME = 'syncFileName';\nPutFile.KEY_FILE_TYPE = 'fileType';\nPutFile.KEY_PERSISTENT_FILE = 'persistentFile';\nPutFile.KEY_SYSTEM_FILE = 'systemFile';\nPutFile.KEY_OFFSET = 'offset';\nPutFile.KEY_LENGTH = 'length';\nPutFile.KEY_CRC = 'crc';\n\nexport { PutFile };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcResponse } from '../RpcResponse.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass PutFileResponse extends RpcResponse {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PutFile);\n    }\n\n\n    /**\n    * @param {Number} spaceAvailable\n    * @return {PutFileResponse}\n    */\n    setSpaceAvailable (spaceAvailable) {\n        this.setParameter(PutFileResponse.KEY_SPACE_AVAILABLE, spaceAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getSpaceAvailable () {\n        return this.getParameter(PutFileResponse.KEY_SPACE_AVAILABLE);\n    }\n}\n\nPutFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable';\n\nexport { PutFileResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TextFieldName\n * @property {Object} _MAP\n */\nclass TextFieldName extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {String}\n    */\n    static get mainField1 () {\n        return TextFieldName._MAP.mainField1;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get mainField2 () {\n        return TextFieldName._MAP.mainField2;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get mainField3 () {\n        return TextFieldName._MAP.mainField3;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get mainField4 () {\n        return TextFieldName._MAP.mainField4;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get statusBar () {\n        return TextFieldName._MAP.statusBar;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get mediaClock () {\n        return TextFieldName._MAP.mediaClock;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get mediaTrack () {\n        return TextFieldName._MAP.mediaTrack;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get templateTitle () {\n        return TextFieldName._MAP.templateTitle;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get alertText1 () {\n        return TextFieldName._MAP.alertText1;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get alertText2 () {\n        return TextFieldName._MAP.alertText2;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get alertText3 () {\n        return TextFieldName._MAP.alertText3;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get scrollableMessageBody () {\n        return TextFieldName._MAP.scrollableMessageBody;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get initialInteractionText () {\n        return TextFieldName._MAP.initialInteractionText;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get navigationText1 () {\n        return TextFieldName._MAP.navigationText1;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get navigationText2 () {\n        return TextFieldName._MAP.navigationText2;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get ETA () {\n        return TextFieldName._MAP.ETA;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get totalDistance () {\n        return TextFieldName._MAP.totalDistance;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get audioPassThruDisplayText1 () {\n        return TextFieldName._MAP.audioPassThruDisplayText1;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get audioPassThruDisplayText2 () {\n        return TextFieldName._MAP.audioPassThruDisplayText2;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get sliderHeader () {\n        return TextFieldName._MAP.sliderHeader;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get sliderFooter () {\n        return TextFieldName._MAP.sliderFooter;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get menuName () {\n        return TextFieldName._MAP.menuName;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get secondaryText () {\n        return TextFieldName._MAP.secondaryText;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get tertiaryText () {\n        return TextFieldName._MAP.tertiaryText;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get menuTitle () {\n        return TextFieldName._MAP.menuTitle;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get locationName () {\n        return TextFieldName._MAP.locationName;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get locationDescription () {\n        return TextFieldName._MAP.locationDescription;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get addressLines () {\n        return TextFieldName._MAP.addressLines;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get phoneNumber () {\n        return TextFieldName._MAP.phoneNumber;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return TextFieldName._valueForKey(key, TextFieldName._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return TextFieldName._keyForValue(value, TextFieldName._MAP);\n    }\n}\n\nTextFieldName._MAP = Object.freeze({\n    'mainField1': 'mainField1',\n    'mainField2': 'mainField2',\n    'mainField3': 'mainField3',\n    'mainField4': 'mainField4',\n    'statusBar': 'statusBar',\n    'mediaClock': 'mediaClock',\n    'mediaTrack': 'mediaTrack',\n    'templateTitle': 'templateTitle',\n    'alertText1': 'alertText1',\n    'alertText2': 'alertText2',\n    'alertText3': 'alertText3',\n    'scrollableMessageBody': 'scrollableMessageBody',\n    'initialInteractionText': 'initialInteractionText',\n    'navigationText1': 'navigationText1',\n    'navigationText2': 'navigationText2',\n    'ETA': 'ETA',\n    'totalDistance': 'totalDistance',\n    'audioPassThruDisplayText1': 'audioPassThruDisplayText1',\n    'audioPassThruDisplayText2': 'audioPassThruDisplayText2',\n    'sliderHeader': 'sliderHeader',\n    'sliderFooter': 'sliderFooter',\n    'menuName': 'menuName',\n    'secondaryText': 'secondaryText',\n    'tertiaryText': 'tertiaryText',\n    'menuTitle': 'menuTitle',\n    'locationName': 'locationName',\n    'locationDescription': 'locationDescription',\n    'addressLines': 'addressLines',\n    'phoneNumber': 'phoneNumber',\n\n});\n\nexport { TextFieldName };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} CharacterSet\n * @property {Object} _MAP\n */\nclass CharacterSet extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {String}\n    */\n    static get TYPE2SET () {\n        return CharacterSet._MAP.TYPE2SET;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get TYPE5SET () {\n        return CharacterSet._MAP.TYPE5SET;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get CID1SET () {\n        return CharacterSet._MAP.CID1SET;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get CID2SET () {\n        return CharacterSet._MAP.CID2SET;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return CharacterSet._valueForKey(key, CharacterSet._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return CharacterSet._keyForValue(value, CharacterSet._MAP);\n    }\n}\n\nCharacterSet._MAP = Object.freeze({\n    'TYPE2SET': 'TYPE2SET',\n    'TYPE5SET': 'TYPE5SET',\n    'CID1SET': 'CID1SET',\n    'CID2SET': 'CID2SET',\n\n});\n\nexport { CharacterSet };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { TextFieldName } from '../enums/TextFieldName.js';\nimport { CharacterSet } from '../enums/CharacterSet.js';\n\nclass TextField extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {TextFieldName} textFieldName\n    * @return {TextField}\n    */\n    setTextFieldName (textFieldName) {\n        this.validateType(TextFieldName, textFieldName);\n\n        this.setParameter(TextField.KEY_NAME, textFieldName);\n        return this;\n    }\n\n    /**\n    * @return {TextFieldName}\n    */\n    getTextFieldName () {\n        return this.getObject(TextFieldName, TextField.KEY_NAME);\n    }\n\n\n    /**\n    * @param {CharacterSet} textFieldName\n    * @return {TextField}\n    */\n    setCharacterSet (characterSet) {\n        this.validateType(CharacterSet, characterSet);\n\n        this.setParameter(TextField.KEY_CHARACTER_SET, characterSet);\n        return this;\n    }\n\n    /**\n    * @return {CharacterSet}\n    */\n    getCharacterSet () {\n        return this.getObject(CharacterSet, TextField.KEY_CHARACTER_SET);\n    }\n\n    /**\n    * @param {Number} width\n    * @return {TextField}\n    */\n    setWidth (width) {\n        this.setParameter(TextField.KEY_WIDTH, width);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getWidth () {\n        return this.getParameter(TextField.KEY_WIDTH);\n    }\n\n    /**\n    * @param {Number} rows\n    * @return {TextField}\n    */\n    setRows (rows) {\n        this.setParameter(TextField.KEY_ROWS, rows);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getRows () {\n        return this.getParameter(TextField.KEY_ROWS);\n    }\n}\n\nTextField.KEY_NAME = 'name';\nTextField.KEY_CHARACTER_SET = 'characterSet';\nTextField.KEY_WIDTH = 'width';\nTextField.KEY_ROWS = 'rows';\n\nexport { TextField };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass ImageResolution extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Number} resolutionWidth\n    * @return {ImageResolution}\n    */\n    setResolutionWidth (resolutionWidth) {\n        this.setParameter(ImageResolution.KEY_RESOLUTION_WIDTH, resolutionWidth);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getResolutionWidth () {\n        return this.getParameter(ImageResolution.KEY_RESOLUTION_WIDTH);\n    }\n\n    /**\n    * @param {Number} resolutionHeight\n    * @return {ImageResolution}\n    */\n    setResolutionHeight (resolutionHeight) {\n        this.setParameter(ImageResolution.KEY_RESOLUTION_HEIGHT, resolutionHeight);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getResolutionHeight () {\n        return this.getParameter(ImageResolution.KEY_RESOLUTION_HEIGHT);\n    }\n}\n\nImageResolution.KEY_RESOLUTION_WIDTH = 'resolutionWidth';\nImageResolution.KEY_RESOLUTION_HEIGHT = 'resolutionHeight';\n\nexport { ImageResolution };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ImageFieldName\n * @property {Object} _MAP\n */\nclass ImageFieldName extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {String}\n    */\n    static get softButtonImage () {\n        return ImageFieldName._MAP.softButtonImage;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get choiceImage () {\n        return ImageFieldName._MAP.choiceImage;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get choiceSecondaryImage () {\n        return ImageFieldName._MAP.choiceSecondaryImage;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get vrHelpItem () {\n        return ImageFieldName._MAP.vrHelpItem;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get turnIcon () {\n        return ImageFieldName._MAP.turnIcon;\n    }\n\n\n    /**\n    * @return {String}\n    */\n    static get menuIcon () {\n        return ImageFieldName._MAP.menuIcon;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get cmdIcon () {\n        return ImageFieldName._MAP.cmdIcon;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get appIcon () {\n        return ImageFieldName._MAP.appIcon;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get graphic () {\n        return ImageFieldName._MAP.graphic;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get secondaryGraphic () {\n        return ImageFieldName._MAP.secondaryGraphic;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get showConstantTBTIcon () {\n        return ImageFieldName._MAP.showConstantTBTIcon;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get showConstantTBTNextTurnIcon () {\n        return ImageFieldName._MAP.showConstantTBTNextTurnIcon;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get locationImage () {\n        return ImageFieldName._MAP.locationImage;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get alertIcon () {\n        return ImageFieldName._MAP.alertIcon;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return ImageFieldName._valueForKey(key, ImageFieldName._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return ImageFieldName._keyForValue(value, ImageFieldName._MAP);\n    }\n}\n\nImageFieldName._MAP = Object.freeze({\n    'softButtonImage': 'softButtonImage',\n    'choiceImage': 'choiceImage',\n    'choiceSecondaryImage': 'choiceSecondaryImage',\n    'vrHelpItem': 'vrHelpItem',\n    'turnIcon': 'turnIcon',\n    'menuIcon': 'menuIcon',\n    'cmdIcon': 'cmdIcon',\n    'appIcon': 'appIcon',\n    'graphic': 'graphic',\n    'secondaryGraphic': 'secondaryGraphic',\n    'showConstantTBTIcon': 'showConstantTBTIcon',\n    'showConstantTBTNextTurnIcon': 'showConstantTBTNextTurnIcon',\n    'locationImage': 'locationImage',\n    'alertIcon': 'alertIcon',\n\n});\n\nexport { ImageFieldName };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ImageResolution } from './ImageResolution.js';\nimport { FileType } from '../enums/FileType.js';\nimport { ImageFieldName } from '../enums/ImageFieldName.js';\n\nclass ImageField extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {ImageFieldName} imageFieldName\n    * @return {ImageField}\n    */\n    setImageFieldName (imageFieldName) {\n        this.validateType(ImageFieldName, imageFieldName);\n\n        this.setParameter(ImageField.KEY_NAME, imageFieldName);\n        return this;\n    }\n\n    /**\n    * @return {ImageFieldName}\n    */\n    getImageFieldName () {\n        return this.getObject(ImageFieldName, ImageField.KEY_NAME);\n    }\n\n    /**\n    * @param {FileType[]} imageTypeSupported\n    * @return {ImageField}\n    */\n    setImageTypeSupported (imageTypeSupported) {\n        this.validateType(FileType, imageTypeSupported, true);\n\n        this.setParameter(ImageField.KEY_IMAGE_TYPE_SUPPORTED, imageTypeSupported);\n        return this;\n    }\n\n    /**\n    * @return {FileType}\n    */\n    getImageTypeSupported () {\n        return this.getObject(FileType, ImageField.KEY_IMAGE_TYPE_SUPPORTED);\n    }\n\n    /**\n    * @param {ImageResolution} imageResolution\n    * @return {ImageField}\n    */\n    setImageResolution (imageResolution) {\n        this.validateType(ImageResolution, imageResolution);\n\n        this.setParameter(ImageField.KEY_IMAGE_RESOLUTION, imageResolution);\n        return this;\n    }\n\n    /**\n    * @return {ImageResolution}\n    */\n    getImageResolution () {\n        return this.getObject(ImageResolution, ImageField.KEY_IMAGE_RESOLUTION);\n    }\n}\n\nImageField.KEY_NAME = 'name';\nImageField.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported';\nImageField.KEY_IMAGE_RESOLUTION = 'imageResolution';\n\nexport { ImageField };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass TouchEventCapabilities extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n\n    /**\n    * @param {Boolean} pressAvailable\n    * @return {TouchEventCapabilities}\n    */\n    setPressAvailable (pressAvailable) {\n        this.setParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE, pressAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getPressAvailable () {\n        return this.getParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE);\n    }\n\n    /**\n    * @param {Boolean} multiTouchAvailable\n    * @return {TouchEventCapabilities}\n    */\n    setMultiTouchAvailable (multiTouchAvailable) {\n        this.setParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE, multiTouchAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getMultiTouchAvailable () {\n        return this.getParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE);\n    }\n\n\n\n    /**\n    * @param {Boolean} doublePressAvailable\n    * @return {TouchEventCapabilities}\n    */\n    setDoublePressAvailable (doublePressAvailable) {\n        this.setParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE, doublePressAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getDoublePressAvailable () {\n        return this.getParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE);\n    }\n}\n\nTouchEventCapabilities.KEY_PRESS_AVAILABLE = 'pressAvailable';\nTouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE = 'multiTouchAvailable';\nTouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE = 'doublePressAvailable';\n\nexport { TouchEventCapabilities };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ImageResolution } from './ImageResolution.js';\nimport { TouchEventCapabilities } from './TouchEventCapabilities.js';\n\nclass ScreenParams extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n\n    /**\n    * @param {ImageResolution} resolution\n    * @return {ScreenParams}\n    */\n    setResolution (resolution) {\n        this.validateType(ImageResolution, resolution);\n\n        this.setParameter(ScreenParams.KEY_RESOLUTION, resolution);\n        return this;\n    }\n\n    /**\n    * @return {ImageResolution}\n    */\n    getResolution () {\n        return this.getObject(ImageResolution, ScreenParams.KEY_RESOLUTION);\n    }\n\n    /**\n    * @param {TouchEventCapabilities} touchEventCapabilities\n    * @return {ScreenParams}\n    */\n    setTouchEventAvailable (touchEventCapabilities) {\n        this.validateType(TouchEventCapabilities, touchEventCapabilities);\n\n        this.setParameter(ScreenParams.KEY_TOUCH_EVENT_AVAILABLE, touchEventCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {TouchEventCapabilities}\n    */\n    getTouchEventAvailable () {\n        return this.getObject(TouchEventCapabilities, ScreenParams.KEY_TOUCH_EVENT_AVAILABLE);\n    }\n}\n\nScreenParams.KEY_RESOLUTION = 'resolution';\nScreenParams.KEY_TOUCH_EVENT_AVAILABLE = 'touchEventAvailable';\n\nexport { ScreenParams };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} DisplayType\n * @property {Object} _MAP\n */\nclass DisplayType extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CID () {\n        return DisplayType._MAP.CID;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TYPE2 () {\n        return DisplayType._MAP.TYPE2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TYPE5 () {\n        return DisplayType._MAP.TYPE5;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NGN () {\n        return DisplayType._MAP.NGN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GEN2_8_DMA () {\n        return DisplayType._MAP.GEN2_8_DMA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GEN2_6_DMA () {\n        return DisplayType._MAP.GEN2_6_DMA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MFD3 () {\n        return DisplayType._MAP.MFD3;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MFD4 () {\n        return DisplayType._MAP.MFD4;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MFD5 () {\n        return DisplayType._MAP.MFD5;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GEN3_8_INCH () {\n        return DisplayType._MAP.GEN3_8_INCH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SDL_GENERIC () {\n        return DisplayType._MAP.SDL_GENERIC;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return DisplayType._valueForKey(key, DisplayType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return DisplayType._keyForValue(value, DisplayType._MAP);\n    }\n}\n\nDisplayType._MAP = Object.freeze({\n    'CID': 'CID',\n    'TYPE2': 'TYPE2',\n    'TYPE5': 'TYPE5',\n    'NGN': 'NGN',\n    'GEN2_8_DMA': 'GEN2_8_DMA',\n    'GEN2_6_DMA': 'GEN2_6_DMA',\n    'MFD3': 'MFD3',\n    'MFD4': 'MFD4',\n    'TESTING': 'TESTING',\n    'MFD5': 'MFD5',\n    'GEN3_8_INCH': 'GEN3_8-INCH',\n    'SDL_GENERIC': 'SDL_GENERIC',\n});\n\nexport { DisplayType };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} MediaClockFormat\n * @property {Object} _MAP\n */\nclass MediaClockFormat extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOCK1 () {\n        return MediaClockFormat._MAP.CLOCK1;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOCK2 () {\n        return MediaClockFormat._MAP.CLOCK2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOCK3 () {\n        return MediaClockFormat._MAP.CLOCK3;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOCKTEXT1 () {\n        return MediaClockFormat._MAP.CLOCKTEXT1;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOCKTEXT2 () {\n        return MediaClockFormat._MAP.CLOCKTEXT2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOCKTEXT3 () {\n        return MediaClockFormat._MAP.CLOCKTEXT3;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOCKTEXT4 () {\n        return MediaClockFormat._MAP.CLOCKTEXT4;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return MediaClockFormat._valueForKey(key, MediaClockFormat._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return MediaClockFormat._keyForValue(value, MediaClockFormat._MAP);\n    }\n}\n\nMediaClockFormat._MAP = Object.freeze({\n    'CLOCK1': 'CLOCK1',\n    'CLOCK2': 'CLOCK2',\n    'CLOCK3': 'CLOCK3',\n    'CLOCKTEXT1': 'CLOCKTEXT1',\n    'CLOCKTEXT2': 'CLOCKTEXT2',\n    'CLOCKTEXT3': 'CLOCKTEXT3',\n    'CLOCKTEXT4': 'CLOCKTEXT4',\n});\n\nexport { MediaClockFormat };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { TextField } from './TextField.js';\nimport { ImageField } from './ImageField.js';\nimport { ScreenParams } from './ScreenParams.js';\nimport { DisplayType } from '../enums/DisplayType.js';\nimport { MediaClockFormat } from '../enums/MediaClockFormat.js';\n\nclass DisplayCapabilities extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {DisplayType} displayType\n    * @return {DisplayCapabilities}\n    */\n    setDisplayType (displayType) {\n        this.validateType(DisplayType, displayType);\n\n        this.setParameter(DisplayCapabilities.KEY_DISPLAY_TYPE, displayType);\n        return this;\n    }\n\n    /**\n    * @return {DisplayType}\n    */\n    getDisplayType () {\n        return this.getObject(DisplayType, DisplayCapabilities.KEY_DISPLAY_TYPE);\n    }\n\n\n    /**\n    * @param {String} displayName\n    * @return {DisplayCapabilities}\n    */\n    setDisplayName (displayName) {\n        this.setParameter(DisplayCapabilities.KEY_DISPLAY_NAME, displayName);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getDisplayName () {\n        return this.getParameter(DisplayCapabilities.KEY_DISPLAY_NAME);\n    }\n\n    /**\n    * @param {Array<TextField>} textFields\n    * @return {DisplayCapabilities}\n    */\n    setTextFields (textFields) {\n        // TODO make work with arrays\n        // this.validateType(TextField, textFields);\n\n        this.setParameter(DisplayCapabilities.KEY_TEXT_FIELDS, textFields);\n        return this;\n    }\n\n    /**\n    * @return {Array<TextField>}\n    */\n    getTextFields () {\n        return this.getObject(TextField, DisplayCapabilities.KEY_TEXT_FIELDS);\n    }\n\n\n    /**\n    * @param {Array<ImageField>} imageFields\n    * @return {DisplayCapabilities}\n    */\n    setImageFields (imageFields) {\n        // TODO make work with arrays\n        // this.validateType(ImageField, imageFields);\n\n        this.setParameter(DisplayCapabilities.KEY_IMAGE_FIELDS, imageFields);\n        return this;\n    }\n\n    /**\n    * @return {Array<ImageField>}\n    */\n    getImageFields () {\n        return this.getObject(ImageField, DisplayCapabilities.KEY_IMAGE_FIELDS);\n    }\n\n    /**\n    * @param {Array<MediaClockFormat>} mediaClockFormats\n    * @return {DisplayCapabilities}\n    */\n    setMediaClockFormats (mediaClockFormats) {\n        // TODO make work with arrays\n        // this.validateType(ImageField, mediaClockFormats);\n\n        this.setParameter(DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS, mediaClockFormats);\n        return this;\n    }\n\n    /**\n    * @return {Array<MediaClockFormat>}\n    */\n    getMediaClockFormats () {\n        return this.getObject(MediaClockFormat, DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS);\n    }\n\n\n    /**\n    * @param {Boolean} graphicSupported\n    * @return {DisplayCapabilities}\n    */\n    setGraphicsSupported (graphicSupported) {\n        this.setParameter(DisplayCapabilities.KEY_GRAPHICS_SUPPORTED, graphicSupported);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getGraphicsSupported () {\n        return this.getParameter(DisplayCapabilities.KEY_GRAPHICS_SUPPORTED);\n    }\n\n    /**\n    * @param {Array<String>} templatesAvailable\n    * @return {DisplayCapabilities}\n    */\n    setTemplatesAvailable (templatesAvailable) {\n        // TODO make work with arrays\n        // this.validateType(String, templatesAvailable);\n\n        this.setParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE, templatesAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Array<String>}\n    */\n    getTemplatesAvailable () {\n        return this.getParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE);\n    }\n\n    /**\n    * @param {ScreenParams} screenParams\n    * @return {DisplayCapabilities}\n    */\n    setScreenParams (screenParams) {\n        this.validateType(ScreenParams, screenParams);\n\n        this.setParameter(DisplayCapabilities.KEY_SCREEN_PARAMS, screenParams);\n        return this;\n    }\n\n    /**\n    * @return {ScreenParams}\n    */\n    getScreenParams () {\n        return this.getObject(ScreenParams, DisplayCapabilities.KEY_SCREEN_PARAMS);\n    }\n    /**\n    * @param {Array<Number>} numCustomPresetsAvailable\n    * @return {DisplayCapabilities}\n    */\n    setNumCustomPresetsAvailable (numCustomPresetsAvailable) {\n        // TODO make work with arrays\n        // this.validateType(Number, numCustomPresetsAvailable);\n\n        this.setParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, numCustomPresetsAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Array<Number>}\n    */\n    getNumCustomPresetsAvailable () {\n        return this.getParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE);\n    }\n}\n\nDisplayCapabilities.KEY_DISPLAY_TYPE = 'displayType';\nDisplayCapabilities.KEY_DISPLAY_NAME = 'displayName';\nDisplayCapabilities.KEY_TEXT_FIELDS = 'textFields';\nDisplayCapabilities.KEY_IMAGE_FIELDS = 'imageFields';\nDisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS = 'mediaClockFormats';\nDisplayCapabilities.KEY_GRAPHICS_SUPPORTED = 'graphicSupported';\nDisplayCapabilities.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable';\nDisplayCapabilities.KEY_SCREEN_PARAMS = 'screenParams';\nDisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable';\n\nexport { DisplayCapabilities };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass Grid extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Number} column\n    * @return {Grid}\n    */\n    setColumn (column) {\n        this.setParameter(Grid.KEY_COLUMN, column);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getColumn () {\n        return this.getParameter(Grid.KEY_COLUMN);\n    }\n\n    /**\n    * @param {Number} row\n    * @return {Grid}\n    */\n    setRow (row) {\n        this.setParameter(Grid.KEY_ROW, row);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getRow () {\n        return this.getParameter(Grid.KEY_ROW);\n    }\n\n    /**\n    * @param {Number} level\n    * @return {Grid}\n    */\n    setLevel (level) {\n        this.setParameter(Grid.KEY_LEVEL, level);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getLevel () {\n        return this.getParameter(Grid.KEY_LEVEL);\n    }\n\n    /**\n    * @param {Number} columnSpan\n    * @return {Grid}\n    */\n    setColumnSpan (columnSpan) {\n        this.setParameter(Grid.KEY_COLUMN_SPAN, columnSpan);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getColumnSpan () {\n        return this.getParameter(Grid.KEY_COLUMN_SPAN);\n    }\n\n    /**\n    * @param {Number} rowSpan\n    * @return {Grid}\n    */\n    setRowSpan (rowSpan) {\n        this.setParameter(Grid.KEY_ROW_SPAN, rowSpan);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getRowSpan () {\n        return this.getParameter(Grid.KEY_ROW_SPAN);\n    }\n\n    /**\n    * @param {Number} levelSpan\n    * @return {Grid}\n    */\n    setLevelSpan (levelSpan) {\n        this.setParameter(Grid.KEY_LEVEL_SPAN, levelSpan);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getLevelSpan () {\n        return this.getParameter(Grid.KEY_LEVEL_SPAN);\n    }\n}\n\nGrid.KEY_COLUMN = 'col';\nGrid.KEY_ROW = 'row';\nGrid.KEY_LEVEL = 'level';\nGrid.KEY_COLUMN_SPAN = 'colspan';\nGrid.KEY_ROW_SPAN = 'rowspan';\nGrid.KEY_LEVEL_SPAN = 'levelspan';\n\nexport { Grid };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { Grid } from './Grid.js';\n\nclass ModuleInfo extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {String} moduleId\n    * @return {ModuleInfo}\n    */\n    setModuleId (moduleId) {\n        this.setParameter(ModuleInfo.KEY_MODULE_ID, moduleId);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getModuleId () {\n        return this.getParameter(ModuleInfo.KEY_MODULE_ID);\n    }\n\n\n    /**\n    * @param {Grid} location\n    * @return {ModuleInfo}\n    */\n    setLocation (location) {\n        this.validateType(Grid, location);\n\n        this.setParameter(ModuleInfo.KEY_LOCATION, location);\n        return this;\n    }\n\n    /**\n    * @return {Grid}\n    */\n    getLocation () {\n        return this.getObject(Grid, ModuleInfo.KEY_LOCATION);\n    }\n\n    /**\n    * @param {Grid} serviceArea\n    * @return {ModuleInfo}\n    */\n    setServiceArea (serviceArea) {\n        this.validateType(Grid, serviceArea);\n\n        this.setParameter(ModuleInfo.KEY_SERVICE_AREA, serviceArea);\n        return this;\n    }\n\n    /**\n    * @return {Grid}\n    */\n    getServiceArea () {\n        return this.getObject(Grid, ModuleInfo.KEY_SERVICE_AREA);\n    }\n\n    /**\n    * @param {Boolean} allowMultipleAccess\n    * @return {ModuleInfo}\n    */\n    setAllowMultipleAccess (allowMultipleAccess) {\n        this.setParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS, allowMultipleAccess);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getAllowMultipleAccess () {\n        return this.getParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS);\n    }\n}\n\nModuleInfo.KEY_MODULE_ID = 'moduleId';\nModuleInfo.KEY_LOCATION = 'location';\nModuleInfo.KEY_SERVICE_AREA = 'serviceArea';\nModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS = 'allowMultipleAccess';\n\nexport { ModuleInfo };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ButtonName\n * @property {Object} _MAP\n */\nclass ButtonName extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OK () {\n        return ButtonName._MAP.OK;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PLAY_PAUSE () {\n        return ButtonName._MAP.PLAY_PAUSE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEEKLEFT () {\n        return ButtonName._MAP.SEEKLEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEEKRIGHT () {\n        return ButtonName._MAP.SEEKRIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TUNEUP () {\n        return ButtonName._MAP.TUNEUP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TUNEDOWN () {\n        return ButtonName._MAP.TUNEDOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_0 () {\n        return ButtonName._MAP.PRESET_0;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_1 () {\n        return ButtonName._MAP.PRESET_1;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_2 () {\n        return ButtonName._MAP.PRESET_2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_3 () {\n        return ButtonName._MAP.PRESET_3;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_4 () {\n        return ButtonName._MAP.PRESET_4;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_5 () {\n        return ButtonName._MAP.PRESET_5;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_6 () {\n        return ButtonName._MAP.PRESET_6;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_7 () {\n        return ButtonName._MAP.PRESET_7;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_8 () {\n        return ButtonName._MAP.PRESET_8;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_9 () {\n        return ButtonName._MAP.PRESET_9;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CUSTOM_BUTTON () {\n        return ButtonName._MAP.CUSTOM_BUTTON;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEARCH () {\n        return ButtonName._MAP.SEARCH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AC_MAX () {\n        return ButtonName._MAP.AC_MAX;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AC () {\n        return ButtonName._MAP.AC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RECIRCULATE () {\n        return ButtonName._MAP.RECIRCULATE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FAN_UP () {\n        return ButtonName._MAP.FAN_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FAN_DOWN () {\n        return ButtonName._MAP.FAN_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TEMP_UP () {\n        return ButtonName._MAP.TEMP_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TEMP_DOWN () {\n        return ButtonName._MAP.TEMP_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFROST_MAX () {\n        return ButtonName._MAP.DEFROST_MAX;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFROST () {\n        return ButtonName._MAP.DEFROST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFROST_REAR () {\n        return ButtonName._MAP.DEFROST_REAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UPPER_VENT () {\n        return ButtonName._MAP.UPPER_VENT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LOWER_VENT () {\n        return ButtonName._MAP.LOWER_VENT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VOLUME_UP () {\n        return ButtonName._MAP.VOLUME_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VOLUME_DOWN () {\n        return ButtonName._MAP.VOLUME_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EJECT () {\n        return ButtonName._MAP.EJECT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SOURCE () {\n        return ButtonName._MAP.SOURCE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SHUFFLE () {\n        return ButtonName._MAP.SHUFFLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REPEAT () {\n        return ButtonName._MAP.REPEAT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_CENTER_LOCATION () {\n        return ButtonName._MAP.NAV_CENTER_LOCATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ZOOM_IN () {\n        return ButtonName._MAP.NAV_ZOOM_IN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ZOOM_OUT () {\n        return ButtonName._MAP.NAV_ZOOM_OUT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_UP () {\n        return ButtonName._MAP.NAV_PAN_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_UP_RIGHT () {\n        return ButtonName._MAP.NAV_PAN_UP_RIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_RIGHT () {\n        return ButtonName._MAP.NAV_PAN_RIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_DOWN_RIGHT () {\n        return ButtonName._MAP.NAV_PAN_DOWN_RIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_DOWN () {\n        return ButtonName._MAP.NAV_PAN_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_DOWN_LEFT () {\n        return ButtonName._MAP.NAV_PAN_DOWN_LEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_LEFT () {\n        return ButtonName._MAP.NAV_PAN_LEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_UP_LEFT () {\n        return ButtonName._MAP.NAV_PAN_UP_LEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_TILT_TOGGLE () {\n        return ButtonName._MAP.NAV_TILT_TOGGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ROTATE_CLOCKWISE () {\n        return ButtonName._MAP.NAV_ROTATE_CLOCKWISE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ROTATE_COUNTERCLOCKWISE () {\n        return ButtonName._MAP.NAV_ROTATE_COUNTERCLOCKWISE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_HEADING_TOGGLE () {\n        return ButtonName._MAP.NAV_HEADING_TOGGLE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return ButtonName._valueForKey(key, ButtonName._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return ButtonName._keyForValue(value, ButtonName._MAP);\n    }\n}\n\nButtonName._MAP = Object.freeze({\n    'OK': 'OK',\n    'PLAY_PAUSE': 'PLAY_PAUSE',\n    'SEEKLEFT': 'SEEKLEFT',\n    'SEEKRIGHT': 'SEEKRIGHT',\n    'TUNEUP': 'TUNEUP',\n    'TUNEDOWN': 'TUNEDOWN',\n    'PRESET_0': 'PRESET_0',\n    'PRESET_1': 'PRESET_1',\n    'PRESET_2': 'PRESET_2',\n    'PRESET_3': 'PRESET_3',\n    'PRESET_4': 'PRESET_4',\n    'PRESET_5': 'PRESET_5',\n    'PRESET_6': 'PRESET_6',\n    'PRESET_7': 'PRESET_7',\n    'PRESET_8': 'PRESET_8',\n    'PRESET_9': 'PRESET_9',\n    'CUSTOM_BUTTON': 'CUSTOM_BUTTON',\n    'SEARCH': 'SEARCH',\n    'AC_MAX': 'AC_MAX',\n    'AC': 'AC',\n    'RECIRCULATE': 'RECIRCULATE',\n    'FAN_UP': 'FAN_UP',\n    'FAN_DOWN': 'FAN_DOWN',\n    'TEMP_UP': 'TEMP_UP',\n    'TEMP_DOWN': 'TEMP_DOWN',\n    'DEFROST_MAX': 'DEFROST_MAX',\n    'DEFROST': 'DEFROST',\n    'DEFROST_REAR': 'DEFROST_REAR',\n    'UPPER_VENT': 'UPPER_VENT',\n    'LOWER_VENT': 'LOWER_VENT',\n    'VOLUME_UP': 'VOLUME_UP',\n    'VOLUME_DOWN': 'VOLUME_DOWN',\n    'EJECT': 'EJECT',\n    'SOURCE': 'SOURCE',\n    'SHUFFLE': 'SHUFFLE',\n    'REPEAT': 'REPEAT',\n    'NAV_CENTER_LOCATION': 'NAV_CENTER_LOCATION',\n    'NAV_ZOOM_IN': 'NAV_ZOOM_IN',\n    'NAV_ZOOM_OUT': 'NAV_ZOOM_OUT',\n    'NAV_PAN_UP': 'NAV_PAN_UP',\n    'NAV_PAN_UP_RIGHT': 'NAV_PAN_UP_RIGHT',\n    'NAV_PAN_RIGHT': 'NAV_PAN_RIGHT',\n    'NAV_PAN_DOWN_RIGHT': 'NAV_PAN_DOWN_RIGHT',\n    'NAV_PAN_DOWN': 'NAV_PAN_DOWN',\n    'NAV_PAN_DOWN_LEFT': 'NAV_PAN_DOWN_LEFT',\n    'NAV_PAN_LEFT': 'NAV_PAN_LEFT',\n    'NAV_PAN_UP_LEFT': 'NAV_PAN_UP_LEFT',\n    'NAV_TILT_TOGGLE': 'NAV_TILT_TOGGLE',\n    'NAV_ROTATE_CLOCKWISE': 'NAV_ROTATE_CLOCKWISE',\n    'NAV_ROTATE_COUNTERCLOCKWISE': 'NAV_ROTATE_COUNTERCLOCKWISE',\n    'NAV_HEADING_TOGGLE': 'NAV_HEADING_TOGGLE',\n\n});\n\nexport { ButtonName };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ModuleInfo } from './ModuleInfo';\nimport { ButtonName } from '../enums/ButtonName.js';\n\nclass ButtonCapabilities extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {ButtonName} name\n    * @return {ButtonCapabilities}\n    */\n    setName (name) {\n        this.validateType(ButtonName, name);\n\n        this.setParameter(ButtonCapabilities.KEY_NAME, name);\n        return this;\n    }\n\n    /**\n    * @return {ButtonName}\n    */\n    getName () {\n        return this.getObject(ButtonName, ButtonCapabilities.KEY_NAME);\n    }\n\n    /**\n    * @param {ModuleInfo} moduleInfo\n    * @return {ButtonCapabilities}\n    */\n    setModuleInfo (moduleInfo) {\n        this.validateType(ModuleInfo, moduleInfo);\n\n        this.setParameter(ButtonCapabilities.KEY_MODULE_INFO, moduleInfo);\n        return this;\n    }\n\n    /**\n    * @return {ModuleInfo}\n    */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, ButtonCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n    * @param {Boolean} shortPressAvailable\n    * @return {ButtonCapabilities}\n    */\n    setShortPressAvailable (shortPressAvailable) {\n        this.setParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, shortPressAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getShortPressAvailable () {\n        return this.getParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE);\n    }\n\n    /**\n    * @param {Boolean} longPressAvailable\n    * @return {ButtonCapabilities}\n    */\n    setLongPressAvailable (longPressAvailable) {\n        this.setParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, longPressAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getLongPressAvailable () {\n        return this.getParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE);\n    }\n\n    /**\n    * @param {Boolean} upDownAvailable\n    * @return {ButtonCapabilities}\n    */\n    setUpDownAvailable (upDownAvailable) {\n        this.setParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE, upDownAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getUpDownAvailable () {\n        return this.getParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE);\n    }\n}\n\nButtonCapabilities.KEY_NAME = 'name';\nButtonCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable';\nButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable';\nButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable';\n\nexport { ButtonCapabilities };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass SoftButtonCapabilities extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Boolean} shortPressAvailable\n    * @return {SoftButtonCapabilities}\n    */\n    setShortPressAvailable (shortPressAvailable) {\n        this.setParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, shortPressAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getShortPressAvailable () {\n        return this.getParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE);\n    }\n\n    /**\n    * @param {Boolean} longPressAvailable\n    * @return {SoftButtonCapabilities}\n    */\n    setLongPressAvailable (longPressAvailable) {\n        this.setParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, longPressAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getLongPressAvailable () {\n        return this.getParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE);\n    }\n\n    /**\n    * @param {Boolean} upDownAvailable\n    * @return {SoftButtonCapabilities}\n    */\n    setUpDownAvailable (upDownAvailable) {\n        this.setParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE, upDownAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getUpDownAvailable () {\n        return this.getParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE);\n    }\n\n    /**\n    * @param {Boolean} imageSupported\n    * @return {SoftButtonCapabilities}\n    */\n    setImageSupported (imageSupported) {\n        this.setParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED, imageSupported);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getImageSupported () {\n        return this.getParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED);\n    }\n\n    /**\n    * @param {Boolean} textSupported\n    * @return {SoftButtonCapabilities}\n    */\n    setTextSupported (textSupported) {\n        this.setParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED, textSupported);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getTextSupported () {\n        return this.getParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED);\n    }\n}\n\nSoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable';\nSoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable';\nSoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable';\nSoftButtonCapabilities.KEY_IMAGE_SUPPORTED = 'imageSupported';\nSoftButtonCapabilities.KEY_TEXT_SUPPORTED = 'textSupported';\n\nexport { SoftButtonCapabilities };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass PresetBankCapabilities extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Boolean} onScreenPresetsAvailable\n    * @return {PresetBankCapabilities}\n    */\n    setOnScreenPresetsAvailable (onScreenPresetsAvailable) {\n        this.setParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE, onScreenPresetsAvailable);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getOnScreenPresetsAvailable () {\n        return this.getParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE);\n    }\n}\n\nPresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE = 'onScreenPresetsAvailable';\n\nexport { PresetBankCapabilities };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass VehicleType extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {String} make\n    * @return {VehicleType}\n    */\n    setMake (make) {\n        this.setParameter(VehicleType.KEY_MAKE, make);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getMake () {\n        return this.getParameter(VehicleType.KEY_MAKE);\n    }\n\n    /**\n    * @param {String} model\n    * @return {VehicleType}\n    */\n    setModel (model) {\n        this.setParameter(VehicleType.KEY_MODEL, model);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getModel () {\n        return this.getParameter(VehicleType.KEY_MODEL);\n    }\n\n    /**\n    * @param {String} modelYear\n    * @return {VehicleType}\n    */\n    setModelYear (modelYear) {\n        this.setParameter(VehicleType.KEY_MODEL_YEAR, modelYear);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getModelYear () {\n        return this.getParameter(VehicleType.KEY_MODEL_YEAR);\n    }\n\n\n    /**\n    * @param {String} trim\n    * @return {VehicleType}\n    */\n    setTrim (trim) {\n        this.setParameter(VehicleType.KEY_TRIM, trim);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getTrim () {\n        return this.getParameter(VehicleType.KEY_TRIM);\n    }\n}\n\nVehicleType.KEY_MAKE = 'make';\nVehicleType.KEY_MODEL = 'model';\nVehicleType.KEY_MODEL_YEAR = 'modelYear';\nVehicleType.KEY_TRIM = 'trim';\n\nexport { VehicleType };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} FileType\n * @property {Object} _MAP\n */\nclass HmiZoneCapabilities extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FRONT () {\n        return HmiZoneCapabilities._MAP.FRONT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BACK () {\n        return HmiZoneCapabilities._MAP.BACK;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return HmiZoneCapabilities._valueForKey(key, HmiZoneCapabilities._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return HmiZoneCapabilities._keyForValue(value, HmiZoneCapabilities._MAP);\n    }\n}\n\nHmiZoneCapabilities._MAP = Object.freeze({\n    'FRONT': 'FRONT',\n    'BACK': 'BACK',\n\n});\n\nexport { HmiZoneCapabilities };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} PrerecordedSpeech\n * @property {Object} _MAP\n */\nclass PrerecordedSpeech extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HELP_JINGLE () {\n        return PrerecordedSpeech._MAP.HELP_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INITIAL_JINGLE () {\n        return PrerecordedSpeech._MAP.INITIAL_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LISTEN_JINGLE () {\n        return PrerecordedSpeech._MAP.LISTEN_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get POSITIVE_JINGLE () {\n        return PrerecordedSpeech._MAP.POSITIVE_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NEGATIVE_JINGLE () {\n        return PrerecordedSpeech._MAP.NEGATIVE_JINGLE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return PrerecordedSpeech._valueForKey(key, PrerecordedSpeech._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return PrerecordedSpeech._keyForValue(value, PrerecordedSpeech._MAP);\n    }\n}\n\nPrerecordedSpeech._MAP = Object.freeze({\n    'HELP_JINGLE': 'HELP_JINGLE',\n    'INITIAL_JINGLE': 'INITIAL_JINGLE',\n    'LISTEN_JINGLE': 'LISTEN_JINGLE',\n    'POSITIVE_JINGLE': 'POSITIVE_JINGLE',\n    'NEGATIVE_JINGLE': 'NEGATIVE_JINGLE',\n\n});\n\nexport { PrerecordedSpeech };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} SamplingRate\n * @property {Object} _MAP\n */\nclass SamplingRate extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SamplingRate_8KHZ () {\n        return SamplingRate._MAP.SamplingRate_8KHZ;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SamplingRate_16KHZ () {\n        return SamplingRate._MAP.SamplingRate_16KHZ;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SamplingRate_22KHZ () {\n        return SamplingRate._MAP.SamplingRate_22KHZ;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SamplingRate_44KHZ () {\n        return SamplingRate._MAP.SamplingRate_44KHZ;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return SamplingRate._valueForKey(key, SamplingRate._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return SamplingRate._keyForValue(value, SamplingRate._MAP);\n    }\n}\n\n// We have to use SamplingRate_ prefix in the name because javascript will not\n// allow the enum to start with a number\nSamplingRate._MAP = Object.freeze({\n    'SamplingRate_8KHZ': '8KHZ',\n    'SamplingRate_16KHZ': '16KHZ',\n    'SamplingRate_22KHZ': '22KHZ',\n    'SamplingRate_44KHZ': '44KHZ',\n\n});\n\nexport { SamplingRate };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} BitsPerSample\n * @property {Object} _MAP\n */\nclass BitsPerSample extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BitsPerSample_8_BIT () {\n        return BitsPerSample._MAP.BitsPerSample_8_BIT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BitsPerSample_16_BIT () {\n        return BitsPerSample._MAP.BitsPerSample_16_BIT;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return BitsPerSample._valueForKey(key, BitsPerSample._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return BitsPerSample._keyForValue(value, BitsPerSample._MAP);\n    }\n}\n\n\n// We have to use BitsPerSample_ prefix in the name because javascript will not\n// allow the enum to start with a number\nBitsPerSample._MAP = Object.freeze({\n    'BitsPerSample_8_BIT': '8_BIT',\n    'BitsPerSample_16_BIT': '16_BIT',\n\n});\n\nexport { BitsPerSample };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} AudioType\n * @property {Object} _MAP\n */\nclass AudioType extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PCM () {\n        return AudioType._MAP.PCM;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return AudioType._valueForKey(key, AudioType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return AudioType._keyForValue(value, AudioType._MAP);\n    }\n}\n\nAudioType._MAP = Object.freeze({\n    'PCM': 'PCM',\n\n});\n\nexport { AudioType };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SamplingRate } from '../enums/SamplingRate.js';\nimport { BitsPerSample } from '../enums/BitsPerSample.js';\nimport { AudioType } from '../enums/AudioType.js';\n\nclass AudioPassThruCapabilities extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {SamplingRate} samplingRate\n    * @return {AudioPassThruCapabilities}\n    */\n    setSamplingRate (samplingRate) {\n        this.validateType(SamplingRate, samplingRate);\n\n        this.setParameter(AudioPassThruCapabilities.KEY_SAMPLING_RATE, samplingRate);\n        return this;\n    }\n\n    /**\n    * @return {SamplingRate}\n    */\n    getSamplingRate () {\n        return this.getObject(SamplingRate, AudioPassThruCapabilities.KEY_SAMPLING_RATE);\n    }\n\n    /**\n    * @param {BitsPerSample} bitsPerSample\n    * @return {AudioPassThruCapabilities}\n    */\n    setBitsPerSample (bitsPerSample) {\n        this.validateType(BitsPerSample, bitsPerSample);\n\n        this.setParameter(AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE, bitsPerSample);\n        return this;\n    }\n\n    /**\n    * @return {BitsPerSample}\n    */\n    getBitsPerSample () {\n        return this.getObject(BitsPerSample, AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE);\n    }\n\n    /**\n    * @param {AudioType} bitsPerSample\n    * @return {AudioPassThruCapabilities}\n    */\n    setAudioType (audioType) {\n        this.validateType(AudioType, audioType);\n\n        this.setParameter(AudioPassThruCapabilities.KEY_AUDIO_TYPE, audioType);\n        return this;\n    }\n\n    /**\n    * @return {AudioType}\n    */\n    getAudioType () {\n        return this.getObject(AudioType, AudioPassThruCapabilities.KEY_AUDIO_TYPE);\n    }\n}\n\nAudioPassThruCapabilities.KEY_SAMPLING_RATE = 'samplingRate';\nAudioPassThruCapabilities.KEY_BITS_PER_SAMPLE = 'bitsPerSample';\nAudioPassThruCapabilities.KEY_AUDIO_TYPE = 'audioType';\n\nexport { AudioPassThruCapabilities };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} VrCapabilities\n * @property {Object} _MAP\n */\nclass VrCapabilities extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VR_TEXT () {\n        return VrCapabilities._MAP.VR_TEXT;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return VrCapabilities._valueForKey(key, VrCapabilities._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return VrCapabilities._keyForValue(value, VrCapabilities._MAP);\n    }\n}\n\nVrCapabilities._MAP = Object.freeze({\n    'VR_TEXT': 'TEXT',\n});\n\nexport { VrCapabilities };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n\nclass HMICapabilities extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Boolean} navigation\n    * @return {HMICapabilities}\n    */\n    setNavigation (navigation) {\n        this.setParameter(HMICapabilities.KEY_NAVIGATION, navigation);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getNavigation () {\n        return this.getParameter(HMICapabilities.KEY_NAVIGATION);\n    }\n\n    /**\n    * @param {Boolean} phoneCall\n    * @return {HMICapabilities}\n    */\n    setPhoneCall (phoneCall) {\n        this.setParameter(HMICapabilities.KEY_PHONE_CALL, phoneCall);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getPhoneCall () {\n        return this.getParameter(HMICapabilities.KEY_PHONE_CALL);\n    }\n\n    /**\n    * @param {Boolean} videoStreaming\n    * @return {HMICapabilities}\n    */\n    setVideoStreaming (videoStreaming) {\n        this.setParameter(HMICapabilities.KEY_VIDEO_STREAMING, videoStreaming);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getVideoStreaming () {\n        return this.getParameter(HMICapabilities.KEY_VIDEO_STREAMING);\n    }\n\n    /**\n    * @param {Boolean} remoteControl\n    * @return {HMICapabilities}\n    */\n    setRemoteControl (remoteControl) {\n        this.setParameter(HMICapabilities.KEY_REMOTE_CONTROL, remoteControl);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getRemoteControl () {\n        return this.getParameter(HMICapabilities.KEY_REMOTE_CONTROL);\n    }\n\n    /**\n    * @param {Boolean} appServices\n    * @return {HMICapabilities}\n    */\n    setAppService (appServices) {\n        this.setParameter(HMICapabilities.KEY_APP_SERVICES, appServices);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getAppService () {\n        return this.getParameter(HMICapabilities.KEY_APP_SERVICES);\n    }\n\n\n    /**\n    * @param {Boolean} displays\n    * @return {HMICapabilities}\n    */\n    setDisplays (displays) {\n        this.setParameter(HMICapabilities.KEY_DISPLAYS, displays);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getDisplays () {\n        return this.getParameter(HMICapabilities.KEY_DISPLAYS);\n    }\n\n\n    /**\n    * @param {Boolean} seatLocation\n    * @return {HMICapabilities}\n    */\n    setSeatLocation (seatLocation) {\n        this.setParameter(HMICapabilities.KEY_SEAT_LOCATION, seatLocation);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getSeatLocation () {\n        return this.getParameter(HMICapabilities.KEY_SEAT_LOCATION);\n    }\n}\n\nHMICapabilities.KEY_NAVIGATION = 'navigation';\nHMICapabilities.KEY_PHONE_CALL = 'phoneCall';\nHMICapabilities.KEY_VIDEO_STREAMING = 'videoStreaming';\nHMICapabilities.KEY_REMOTE_CONTROL = 'remoteControl';\nHMICapabilities.KEY_APP_SERVICES = 'appServices';\nHMICapabilities.KEY_DISPLAYS = 'displays';\nHMICapabilities.KEY_SEAT_LOCATION = 'seatLocation';\n\nexport { HMICapabilities };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcResponse } from '../RpcResponse.js';\nimport { SdlMsgVersion } from '../structs/SdlMsgVersion.js';\nimport { DisplayCapabilities } from '../structs/DisplayCapabilities.js';\nimport { ButtonCapabilities } from '../structs/ButtonCapabilities.js';\nimport { SoftButtonCapabilities } from '../structs/SoftButtonCapabilities.js';\nimport { PresetBankCapabilities } from '../structs/PresetBankCapabilities.js';\nimport { VehicleType } from '../structs/VehicleType.js';\nimport { Language } from '../enums/Language.js';\nimport { HmiZoneCapabilities } from '../enums/HmiZoneCapabilities.js';\nimport { SpeechCapabilities } from '../enums/SpeechCapabilities.js';\nimport { PrerecordedSpeech } from '../enums/PrerecordedSpeech.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { AudioPassThruCapabilities } from '../structs/AudioPassThruCapabilities.js';\nimport { VrCapabilities } from '../enums/VrCapabilities.js';\nimport { HMICapabilities } from '../structs/HMICapabilities.js';\n\nclass RegisterAppInterfaceResponse extends RpcResponse {\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.RegisterAppInterface);\n    }\n\n    /**\n    * @param {SdlMsgVersion} The max RPC Spec version supported by this library\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setSdlMsgVersion (sdlMsgVersion) {\n        this.validateType(SdlMsgVersion, sdlMsgVersion);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION, sdlMsgVersion);\n        return this;\n    }\n\n    /**\n    * @return {SdlMsgVersion}\n    */\n    getSdlMsgVersion () {\n        return this.getObject(SdlMsgVersion, RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION);\n    }\n\n    /**\n    * @param {Language} language\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setLanguage (language) {\n        this.validateType(Language, language);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getLanguage () {\n        return this.getObject(Language, RegisterAppInterfaceResponse.KEY_LANGUAGE);\n    }\n\n\n    /**\n    * @param {Language} hmiDisplayLanguage\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setHmiDisplayLanguage (hmiDisplayLanguage) {\n        this.validateType(Language, hmiDisplayLanguage);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE, hmiDisplayLanguage);\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getHmiDisplayLanguage () {\n        return this.getObject(Language, RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE);\n    }\n\n    /**\n    * @param {DisplayCapabilities} displayCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setDisplayCapabilities (displayCapabilities) {\n        this.validateType(DisplayCapabilities, displayCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES, displayCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {DisplayCapabilities}\n    */\n    getDisplayCapabilities () {\n        return this.getObject(DisplayCapabilities, RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES);\n    }\n\n\n    /**\n    * @param {Array<ButtonCapabilities>} buttonCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setButtonCapabilities (buttonCapabilities) {\n        // TODO make this work with arrays\n        // this.validateType(Language, buttonCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES, buttonCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {Array<ButtonCapabilities>}\n    */\n    getButtonCapabilities () {\n        return this.getObject(ButtonCapabilities, RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES);\n    }\n\n    /**\n    * @param {Array<SoftButtonCapabilities>} softButtonCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setSoftButtonCapabilities (softButtonCapabilities) {\n        // TODO make this work with arrays\n        // this.validateType(SoftButtonCapabilities, softButtonCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES, softButtonCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {Array<SoftButtonCapabilities>}\n    */\n    getSoftButtonCapabilities () {\n        return this.getObject(SoftButtonCapabilities, RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES);\n    }\n\n    /**\n    * @param {PresetBankCapabilities} presetBankCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setPresetBankCapabilities (presetBankCapabilities) {\n        this.validateType(PresetBankCapabilities, presetBankCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES, presetBankCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {PresetBankCapabilities}\n    */\n    getPresetBankCapabilities () {\n        return this.getObject(PresetBankCapabilities, RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES);\n    }\n\n    /**\n    * @param {Array<HmiZoneCapabilities>} hmiZoneCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setHmiZoneCapabilities (hmiZoneCapabilities) {\n        // TODO make this work for arrays\n        // this.validateType(HmiZoneCapabilities, hmiZoneCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES, hmiZoneCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {Array<HmiZoneCapabilities>}\n    */\n    getHmiZoneCapabilities () {\n        return this.getObject(HmiZoneCapabilities, RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES);\n    }\n\n    /**\n    * @param {Array<SpeechCapabilities>} speechCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setSpeechCapabilities (speechCapabilities) {\n        // TODO make this work for arrays\n        // this.validateType(SpeechCapabilities, speechCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES, speechCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {Array<SpeechCapabilities>}\n    */\n    getSpeechCapabilities () {\n        return this.getObject(SpeechCapabilities, RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES);\n    }\n\n    /**\n    * @param {Array<PrerecordedSpeech>} speechCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setPrerecordedSpeech (speechCapabilities) {\n        // TODO make this work for arrays\n        // this.validateType(PrerecordedSpeech, speechCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH, speechCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {Array<PrerecordedSpeech>}\n    */\n    getPrerecordedSpeech () {\n        return this.getObject(PrerecordedSpeech, RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH);\n    }\n\n    /**\n    * @param {Array<VrCapabilities>} vrCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setVrCapabilities (vrCapabilities) {\n        // TODO make this work for arrays\n        // this.validateType(VrCapabilities, vrCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES, vrCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {Array<VrCapabilities>}\n    */\n    getVrCapabilities () {\n        return this.getObject(VrCapabilities, RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES);\n    }\n\n    /**\n    * @param {Array<AudioPassThruCapabilities>} audioPassThruCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setAudioPassThruCapabilities (audioPassThruCapabilities) {\n        // TODO make this work for arrays\n        // this.validateType(AudioPassThruCapabilities, audioPassThruCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES, audioPassThruCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {Array<AudioPassThruCapabilities>}\n    */\n    getAudioPassThruCapabilities () {\n        return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES);\n    }\n\n    /**\n    * @param {AudioPassThruCapabilities} pcmStreamCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setPcmStreamCapabilities (pcmStreamCapabilities) {\n        this.validateType(AudioPassThruCapabilities, pcmStreamCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES, pcmStreamCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {AudioPassThruCapabilities}\n    */\n    getPcmStreamCapabilities () {\n        return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES);\n    }\n\n    /**\n    * @param {VehicleType} vehicleType\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setVehicleType (vehicleType) {\n        this.validateType(VehicleType, vehicleType);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE, vehicleType);\n        return this;\n    }\n\n    /**\n    * @return {VehicleType}\n    */\n    getVehicleType () {\n        return this.getObject(VehicleType, RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE);\n    }\n\n    /**\n    * @param {Number} supportedDiagModes\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setSupportedDiagModes (supportedDiagModes) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE, supportedDiagModes);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getSupportedDiagModes () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE);\n    }\n\n    /**\n    * @param {HMICapabilities} hmiCapabilities\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setHMICapabilities (hmiCapabilities) {\n        this.validateType(HMICapabilities, hmiCapabilities);\n\n        this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES, hmiCapabilities);\n        return this;\n    }\n\n    /**\n    * @return {HMICapabilities}\n    */\n    getHMICapabilities () {\n        return this.getObject(HMICapabilities, RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES);\n    }\n\n    /**\n    * @param {String} sdlVersion\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setSdlVersion (sdlVersion) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION, sdlVersion);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getSdlVersion () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION);\n    }\n\n    /**\n    * @param {String} systemSoftwareVersion\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setSystemSoftwareVersion (systemSoftwareVersion) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION, systemSoftwareVersion);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getSystemSoftwareVersion () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION);\n    }\n\n    /**\n    * @param {Boolean} iconResumed\n    * @return {RegisterAppInterfaceResponse}\n    */\n    setIconResumed (iconResumed) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED, iconResumed);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getIconResumed () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED);\n    }\n}\n\nRegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION = 'syncMsgVersion';\nRegisterAppInterfaceResponse.KEY_LANGUAGE = 'language';\nRegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage';\nRegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities';\nRegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities';\nRegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities';\nRegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES = 'presetBankCapabilities';\nRegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES = 'hmiZoneCapabilities';\nRegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES = 'speechCapabilities';\nRegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH = 'prerecordedSpeech';\nRegisterAppInterfaceResponse.KEY_VR_CAPABILITIES = 'vrCapabilities';\nRegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES = 'audioPassThruCapabilities';\nRegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES = 'pcmStreamCapabilities';\nRegisterAppInterfaceResponse.KEY_VEHICLE_TYPE = 'vehicleType';\nRegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODE = 'supportedDiagModes';\nRegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES = 'hmiCapabilities';\nRegisterAppInterfaceResponse.KEY_SDL_VERSION = 'sdlVersion';\nRegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION = 'systemSoftwareVersion';\nRegisterAppInterfaceResponse.KEY_ICON_RESUMED = 'iconResumed';\n\nexport { RegisterAppInterfaceResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass SetAppIcon extends RpcRequest {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetAppIcon);\n    }\n\n    /**\n    * @param {String} fileName\n    * @return {SetAppIcon}\n    */\n    setFileName (fileName) {\n        this.setParameter(SetAppIcon.KEY_FILE_NAME, fileName);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getFileName () {\n        return this.getParameter(SetAppIcon.KEY_FILE_NAME);\n    }\n}\n\nSetAppIcon.KEY_FILE_NAME = 'syncFileName';\n\n\nexport { SetAppIcon };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcResponse } from '../RpcResponse.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass SetAppIconResponse extends RpcResponse {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetAppIcon);\n    }\n}\n\nexport { SetAppIconResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} SoftButtonType\n * @property {Object} _MAP\n */\nclass SoftButtonType extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SBT_TEXT () {\n        return SoftButtonType._MAP.SBT_TEXT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SBT_IMAGE () {\n        return SoftButtonType._MAP.SBT_IMAGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SBT_BOTH () {\n        return SoftButtonType._MAP.SBT_BOTH;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return SoftButtonType._valueForKey(key, SoftButtonType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return SoftButtonType._keyForValue(value, SoftButtonType._MAP);\n    }\n}\n\nSoftButtonType._MAP = Object.freeze({\n    'SBT_TEXT': 'TEXT',\n    'SBT_IMAGE': 'IMAGE',\n    'SBT_BOTH': 'BOTH',\n\n});\n\nexport { SoftButtonType };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} SystemAction\n * @property {Object} _MAP\n */\nclass SystemAction extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFAULT_ACTION () {\n        return SystemAction._MAP.DEFAULT_ACTION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get STEAL_FOCUS () {\n        return SystemAction._MAP.STEAL_FOCUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get KEEP_CONTEXT () {\n        return SystemAction._MAP.KEEP_CONTEXT;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return SystemAction._valueForKey(key, SystemAction._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return SystemAction._keyForValue(value, SystemAction._MAP);\n    }\n}\n\nSystemAction._MAP = Object.freeze({\n    'DEFAULT_ACTION': 'DEFAULT_ACTION',\n    'STEAL_FOCUS': 'STEAL_FOCUS',\n    'KEEP_CONTEXT': 'KEEP_CONTEXT',\n\n});\n\nexport { SystemAction };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SoftButtonType } from '../enums/SoftButtonType.js';\nimport { SystemAction } from '../enums/SystemAction.js';\nimport { Image } from './Image.js';\n\n\nclass SoftButton extends RpcStruct {\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {SoftButtonType} type\n    * @return {SoftButton}\n    */\n    setType (type) {\n        this.validateType(SoftButtonType, type);\n\n        this.setParameter(SoftButton.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n    * @return {SoftButtonType}\n    */\n    getType () {\n        return this.getObject(SoftButtonType, SoftButton.KEY_TYPE);\n    }\n\n    /**\n    * @param {String} text\n    * @return {SoftButton}\n    */\n    setText (text) {\n        this.setParameter(SoftButton.KEY_TEXT, text);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getText () {\n        return this.getParameter(SoftButton.KEY_TEXT);\n    }\n\n    /**\n    * @param {Image} image\n    * @return {SoftButton}\n    */\n    setImage (image) {\n        this.validateType(Image, image);\n\n        this.setParameter(SoftButton.KEY_IMAGE, image);\n        return this;\n    }\n\n    /**\n    * @return {Image}\n    */\n    getImage () {\n        return this.getObject(Image, SoftButton.KEY_IMAGE);\n    }\n\n    /**\n    * @param {Boolean} isHighlighted\n    * @return {SoftButton}\n    */\n    setIsHighlighted (isHighlighted) {\n        this.setParameter(SoftButton.KEY_IS_HIGHLIGHTED, isHighlighted);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getIsHighlighted () {\n        return this.getParameter(SoftButton.KEY_IS_HIGHLIGHTED);\n    }\n\n    /**\n    * @param {Number} softButtonID\n    * @return {SoftButton}\n    */\n    setSoftButtonID (softButtonID) {\n        this.setParameter(SoftButton.KEY_SOFT_BUTTON_ID, softButtonID);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getSoftButtonID () {\n        return this.getParameter(SoftButton.KEY_SOFT_BUTTON_ID);\n    }\n\n\n    /**\n    * @param {SystemAction} systemAction\n    * @return {SoftButton}\n    */\n    setSystemAction (systemAction) {\n        this.validateType(SystemAction, systemAction);\n\n        this.setParameter(SoftButton.KEY_SYSTEM_ACTION, systemAction);\n        return this;\n    }\n\n    /**\n    * @return {SystemAction}\n    */\n    getSystemAction () {\n        return this.getObject(SystemAction, SoftButton.KEY_SYSTEM_ACTION);\n    }\n}\n\nSoftButton.KEY_TYPE = 'type';\nSoftButton.KEY_TEXT = 'text';\nSoftButton.KEY_IMAGE = 'image';\nSoftButton.KEY_IS_HIGHLIGHTED = 'isHighlighted';\nSoftButton.KEY_SOFT_BUTTON_ID = 'softButtonID';\nSoftButton.KEY_SYSTEM_ACTION = 'systemAction';\n\nexport { SoftButton };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} MetadataType\n * @property {Object} _MAP\n */\nclass MetadataType extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get mediaTitle () {\n        return MetadataType._MAP.mediaTitle;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get mediaArtist () {\n        return MetadataType._MAP.mediaArtist;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get mediaAlbum () {\n        return MetadataType._MAP.mediaAlbum;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get mediaYear () {\n        return MetadataType._MAP.mediaYear;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get mediaGenre () {\n        return MetadataType._MAP.mediaGenre;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get mediaStation () {\n        return MetadataType._MAP.mediaStation;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get rating () {\n        return MetadataType._MAP.rating;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get currentTemperature () {\n        return MetadataType._MAP.currentTemperature;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get maximumTemperature () {\n        return MetadataType._MAP.maximumTemperature;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get minimumTemperature () {\n        return MetadataType._MAP.minimumTemperature;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get weatherTerm () {\n        return MetadataType._MAP.weatherTerm;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get humidity () {\n        return MetadataType._MAP.humidity;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return MetadataType._valueForKey(key, MetadataType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return MetadataType._keyForValue(value, MetadataType._MAP);\n    }\n}\n\nMetadataType._MAP = Object.freeze({\n    'mediaTitle': 'mediaTitle',\n    'mediaArtist': 'mediaArtist',\n    'mediaAlbum': 'mediaAlbum',\n    'mediaYear': 'mediaYear',\n    'mediaGenre': 'mediaGenre',\n    'mediaStation': 'mediaStation',\n    'rating': 'rating',\n    'currentTemperature': 'currentTemperature',\n    'maximumTemperature': 'maximumTemperature',\n    'minimumTemperature': 'minimumTemperature',\n    'weatherTerm': 'weatherTerm',\n    'humidity': 'humidity',\n\n});\n\nexport { MetadataType };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { MetadataType } from '../enums/MetadataType.js';\n\nclass MetadataTags extends RpcStruct {\n    /**\n    * @constructor\n    */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n    * @param {Array<MetadataType>} mainField1\n    * @return {MetadataTags}\n    */\n    setMainField1 (mainField1) {\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_1, mainField1);\n        return this;\n    }\n\n    /**\n    * @return {Array<MetadataType>}\n    */\n    getMainField1 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_1);\n    }\n\n    /**\n    * @param {Array<MetadataType>} mainField2\n    * @return {MetadataTags}\n    */\n    setMainField2 (mainField2) {\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_2, mainField2);\n        return this;\n    }\n\n    /**\n    * @return {Array<MetadataType>}\n    */\n    getMainField2 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_2);\n    }\n\n    /**\n    * @param {Array<MetadataType>} mainField3\n    * @return {MetadataTags}\n    */\n    setMainField3 (mainField3) {\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_3, mainField3);\n        return this;\n    }\n\n    /**\n    * @return {Array<MetadataType>}\n    */\n    getMainField3 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_3);\n    }\n\n    /**\n    * @param {Array<MetadataType>} mainField4\n    * @return {MetadataTags}\n    */\n    setMainField4 (mainField4) {\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_4, mainField4);\n        return this;\n    }\n\n    /**\n    * @return {Array<MetadataType>}\n    */\n    getMainField4 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_4);\n    }\n}\n\nMetadataTags.KEY_MAIN_FIELD_1 = 'mainField1';\nMetadataTags.KEY_MAIN_FIELD_2 = 'mainField2';\nMetadataTags.KEY_MAIN_FIELD_3 = 'mainField3';\nMetadataTags.KEY_MAIN_FIELD_4 = 'mainField4';\n\nexport { MetadataTags };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TextAlignment\n * @property {Object} _MAP\n */\nclass TextAlignment extends Enum {\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {String}\n    */\n    static get LEFT_ALIGNED () {\n        return TextAlignment._MAP.LEFT_ALIGNED;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get RIGHT_ALIGNED () {\n        return TextAlignment._MAP.RIGHT_ALIGNED;\n    }\n\n    /**\n    * @return {String}\n    */\n    static get CENTERED () {\n        return TextAlignment._MAP.CENTERED;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return TextAlignment._valueForKey(key, TextAlignment._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return TextAlignment._keyForValue(value, TextAlignment._MAP);\n    }\n}\n\nTextAlignment._MAP = Object.freeze({\n    'LEFT_ALIGNED': 'LEFT_ALIGNED',\n    'RIGHT_ALIGNED': 'RIGHT_ALIGNED',\n    'CENTERED': 'CENTERED',\n\n\n});\n\nexport { TextAlignment };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { SoftButton } from '../structs/SoftButton.js';\nimport { Image } from '../structs/Image.js';\nimport { MetadataTags } from '../structs/MetadataTags.js';\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TextAlignment } from '../enums/TextAlignment.js';\n\nclass Show extends RpcRequest {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Show);\n    }\n\n\n    /**\n    * @param {String} mainField1\n    * @return {Show}\n    */\n    setMainField1 (mainField1) {\n        this.setParameter(Show.KEY_MAIN_FIELD_1, mainField1);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getMainField1 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_1);\n    }\n\n    /**\n    * @param {String} mainField2\n    * @return {Show}\n    */\n    setMainField2 (mainField2) {\n        this.setParameter(Show.KEY_MAIN_FIELD_2, mainField2);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getMainField2 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_2);\n    }\n\n    /**\n    * @param {String} mainField3\n    * @return {Show}\n    */\n    setMainField3 (mainField3) {\n        this.setParameter(Show.KEY_MAIN_FIELD_3, mainField3);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getMainField3 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_3);\n    }\n\n    /**\n    * @param {String} mainField4\n    * @return {Show}\n    */\n    setMainField4 (mainField4) {\n        this.setParameter(Show.KEY_MAIN_FIELD_4, mainField4);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getMainField4 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_4);\n    }\n\n    /**\n    * @param {TextAlignment} menuParams\n    * @return {Show}\n    */\n    setAlignment (alignment) {\n        this.validateType(TextAlignment, alignment);\n\n        this.setParameter(Show.KEY_ALIGNMENT, alignment);\n        return this;\n    }\n\n    /**\n    * @return {TextAlignment}\n    */\n    getAlignment () {\n        return this.getObject(TextAlignment, Show.KEY_ALIGNMENT);\n    }\n\n    /**\n    * @param {String} statusBar\n    * @return {Show}\n    */\n    setStatusBar (statusBar) {\n        this.setParameter(Show.KEY_STATUS_BAR, statusBar);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getStatusBar () {\n        return this.getParameter(Show.KEY_STATUS_BAR);\n    }\n\n    /**\n    * @param {String} mediaClock\n    * @return {Show}\n    */\n    setMediaClock (mediaClock) {\n        this.setParameter(Show.KEY_MEDIA_CLOCK, mediaClock);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getMediaClock () {\n        return this.getParameter(Show.KEY_MEDIA_CLOCK);\n    }\n\n    /**\n    * @param {String} mediaTrack\n    * @return {Show}\n    */\n    setMediaTrack (mediaTrack) {\n        this.setParameter(Show.KEY_MEDIA_TRACK, mediaTrack);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getMediaTrack () {\n        return this.getParameter(Show.KEY_MEDIA_TRACK);\n    }\n\n    /**\n    * @param {Image} graphic\n    * @return {Show}\n    */\n    setGraphic (graphic) {\n        this.validateType(Image, graphic);\n\n        this.setParameter(Show.KEY_GRAPHIC, graphic);\n        return this;\n    }\n\n    /**\n    * @return {Image}\n    */\n    getGraphic () {\n        return this.getObject(Image, Show.KEY_GRAPHIC);\n    }\n\n    /**\n    * @param {Image} secondaryGraphic\n    * @return {Show}\n    */\n    setSecondaryGraphic (secondaryGraphic) {\n        this.validateType(Image, secondaryGraphic);\n\n        this.setParameter(Show.KEY_SECONDARY_GRAPHIC, secondaryGraphic);\n        return this;\n    }\n\n    /**\n    * @return {Image}\n    */\n    getSecondaryGraphic () {\n        return this.getObject(Image, Show.KEY_SECONDARY_GRAPHIC);\n    }\n\n    /**\n    * @param {Array<SoftButton>} softButtons\n    * @return {Show}\n    */\n    setSoftButtons (softButtons) {\n        // TODO make this work for arrays\n        // this.validateType(SoftButton, softButtons);\n\n        this.setParameter(Show.KEY_SOFT_BUTTONS, softButtons);\n        return this;\n    }\n\n    /**\n    * @return {Array<SoftButton>}\n    */\n    getSoftButtons () {\n        return this.getObject(SoftButton, Show.KEY_SOFT_BUTTONS);\n    }\n\n    /**\n    * @param {Array<String>} customPresets\n    * @return {Show}\n    */\n    setCustomPresets (customPresets) {\n        this.setParameter(Show.KEY_CUSTOM_PRESETS, customPresets);\n        return this;\n    }\n\n    /**\n    * @return {Array<String>}\n    */\n    getCustomPresets () {\n        return this.getParameter(Show.KEY_CUSTOM_PRESETS);\n    }\n\n    /**\n    * @param {MetadataTags} metadataTags\n    * @return {Show}\n    */\n    setMetadataTags (metadataTags) {\n        this.validateType(MetadataTags, metadataTags);\n\n        this.setParameter(Show.KEY_METADATA_TAGS, metadataTags);\n        return this;\n    }\n\n    /**\n    * @return {MetadataTags}\n    */\n    getMetadataTags () {\n        return this.getObject(MetadataTags, Show.KEY_METADATA_TAGS);\n    }\n\n    /**\n    * @param {String} templateTitle\n    * @return {Show}\n    */\n    setTemplateTitle (templateTitle) {\n        this.setParameter(Show.KEY_TEMPLATE_TITLE, templateTitle);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getTemplateTitle () {\n        return this.getParameter(Show.KEY_TEMPLATE_TITLE);\n    }\n\n    /**\n    * @param {Number} windowID\n    * @return {Show}\n    */\n    setWindowID (windowID) {\n        this.setParameter(Show.KEY_WINDOW_ID, windowID);\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getWindowID () {\n        return this.getParameter(Show.KEY_WINDOW_ID);\n    }\n}\n\nShow.KEY_MAIN_FIELD_1 = 'mainField1';\nShow.KEY_MAIN_FIELD_2 = 'mainField2';\nShow.KEY_MAIN_FIELD_3 = 'mainField3';\nShow.KEY_MAIN_FIELD_4 = 'mainField4';\nShow.KEY_ALIGNMENT = 'alignment';\nShow.KEY_STATUS_BAR = 'statusBar';\nShow.KEY_MEDIA_CLOCK = 'mediaClock';\nShow.KEY_MEDIA_TRACK = 'mediaTrack';\nShow.KEY_GRAPHIC = 'graphic';\nShow.KEY_SECONDARY_GRAPHIC = 'secondaryGraphic';\nShow.KEY_SOFT_BUTTONS = 'softButtons';\nShow.KEY_CUSTOM_PRESETS = 'customPresets';\nShow.KEY_METADATA_TAGS = 'metadataTags';\nShow.KEY_TEMPLATE_TITLE = 'templateTitle';\nShow.KEY_WINDOW_ID = 'windowID';\n\nexport { Show };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcResponse } from '../RpcResponse.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass ShowResponse extends RpcResponse {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Show);\n    }\n}\n\nexport { ShowResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass UnregisterAppInterface extends RpcRequest {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnregisterAppInterface);\n    }\n}\n\n\nexport { UnregisterAppInterface };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcResponse } from '../RpcResponse.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass UnregisterAppInterfaceResponse extends RpcResponse {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnregisterAppInterface);\n    }\n}\n\nexport { UnregisterAppInterfaceResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n// messages\nimport { AddCommand } from './messages/AddCommand.js';\nimport { AddCommandResponse } from './messages/AddCommandResponse.js';\nimport { OnHmiStatus } from './messages/OnHmiStatus.js';\nimport { OnLanguageChange } from './messages/OnLanguageChange.js';\nimport { PutFile } from './messages/PutFile.js';\nimport { PutFileResponse } from './messages/PutFileResponse.js';\nimport { RegisterAppInterface } from './messages/RegisterAppInterface.js';\nimport { RegisterAppInterfaceResponse } from './messages/RegisterAppInterfaceResponse.js';\nimport { SetAppIcon } from './messages/SetAppIcon.js';\nimport { SetAppIconResponse } from './messages/SetAppIconResponse.js';\nimport { Show } from './messages/Show.js';\nimport { ShowResponse } from './messages/ShowResponse.js';\nimport { UnregisterAppInterface } from './messages/UnregisterAppInterface.js';\nimport { UnregisterAppInterfaceResponse } from './messages/UnregisterAppInterfaceResponse.js';\n\n// other\nimport { RpcType } from './enums/RpcType.js';\nimport { FunctionID } from './enums/FunctionID.js';\nimport { JsonRpcMarshaller } from './../util/JsonRpcMarshaller.js';\nimport { BinaryFrameHeader } from './../protocol/BinaryFrameHeader.js';\n\nclass RpcCreator {\n    /**\n     * Converts an SdlPacket to an RpcMessage\n     * @param {SdlPacket} sdlPacket\n     * @return {RpcMessage}\n     */\n    static construct (sdlPacket) {\n        const payload = sdlPacket.getPayload();\n        const binaryFrameHeader = BinaryFrameHeader.fromBinaryHeader(payload);\n\n        let message;\n        const rpcType = binaryFrameHeader.getRpcType();\n        const rpcName = RpcType.keyForValue(rpcType);\n        const correlationId = binaryFrameHeader.getCorrelationId();\n        const functionId = binaryFrameHeader.getFunctionId();\n        const functionName = FunctionID.keyForValue(functionId);\n        const bulkData = binaryFrameHeader.getBulkData();\n        const jsonData = binaryFrameHeader.getJsonData();\n        const params = {\n            parameters: JsonRpcMarshaller.unmarshall(jsonData),\n        };\n\n        switch (functionId) {\n            case FunctionID.AddCommand:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new AddCommand(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new AddCommandResponse(params);\n                }\n                break;\n            case FunctionID.OnHMIStatus: // TODO: should OnHMIStatus be OnHmiStatus, or the class name change to OnHMIStatus? or is this fine as is?\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnHmiStatus(params);\n                }\n                break;\n            case FunctionID.OnLanguageChange:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnLanguageChange(params);\n                }\n                break;\n            case FunctionID.PutFile:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new PutFile(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new PutFileResponse(params);\n                }\n                break;\n            case FunctionID.RegisterAppInterface:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new RegisterAppInterface(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new RegisterAppInterfaceResponse(params);\n                }\n                break;\n            case FunctionID.SetAppIcon:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SetAppIcon(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SetAppIconResponse(params);\n                }\n                break;\n            case FunctionID.Show:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new Show(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ShowResponse(params);\n                }\n                break;\n            case FunctionID.UnregisterAppInterface:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new UnregisterAppInterface(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new UnregisterAppInterfaceResponse(params);\n                }\n                break;\n            default:\n                message = null;\n        }\n\n        if (message === null || message === undefined) { // informs of missing classes\n            console.warn(`RpcCreator couldn't construct an RPC for the ${functionName} ${rpcName}`);\n            return null;\n        }\n\n        if (rpcType === RpcType.REQUEST || rpcType === RpcType.RESPONSE) {\n            message.setCorrelationId(correlationId);\n        }\n        if (bulkData) {\n            message.setBulkData(bulkData);\n        }\n\n        return message;\n    }\n}\n\nexport { RpcCreator };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} VideoStreamingProtocol\n * @property {Object} _MAP\n */\nclass VideoStreamingProtocol extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n    /**\n     * @return {String}\n     */\n    static get RAW () {\n        return VideoStreamingProtocol._MAP.RAW;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RTP () {\n        return VideoStreamingProtocol._MAP.RTP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RTSP () {\n        return VideoStreamingProtocol._MAP.RTSP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RTMP () {\n        return VideoStreamingProtocol._MAP.RTMP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WEBM () {\n        return VideoStreamingProtocol._MAP.WEBM;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return VideoStreamingProtocol._valueForKey(key, VideoStreamingProtocol._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return VideoStreamingProtocol._keyForValue(value, VideoStreamingProtocol._MAP);\n    }\n}\n\nVideoStreamingProtocol._MAP = Object.freeze({\n    /**\n     * Raw stream bytes that contains no timestamp data and is the lowest supported video streaming\n     */\n    'RAW': 'RAW',\n    /**\n     * RTP facilitates the transfer of real-time data. Information provided by this protocol include\n     * timestamps (for synchronization), sequence numbers (for packet loss and reordering detection)\n     * and the payload format which indicates the encoded format of the data.\n     */\n    'RTP': 'RTP',\n    /**\n     * The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the\n     * Real-time Transport Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP) for\n     * media stream delivery. However, some vendors implement proprietary transport protocols.\n     */\n    'RTSP': 'RTSP',\n    /**\n     * Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by\n     * Macromedia for streaming audio, video and data over the Internet, between a Flash player and\n     * a server. Macromedia is now owned by Adobe, which has released an incomplete version of the\n     * specification of the protocol for public use.\n     */\n    'RTMP': 'RTMP',\n    /**\n     * The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and\n     * Vorbis audio streams. In 2013 it was updated to accommodate VP9 video and Opus audio.\n     */\n    'WEBM': 'WEBM',\n\n});\n\nexport { VideoStreamingProtocol };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} VideoStreamingCodec\n * @property {Object} _MAP\n */\nclass VideoStreamingCodec extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n    /**\n     * @return {String}\n     */\n    static get H264 () {\n        return VideoStreamingCodec._MAP.H264;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get H265 () {\n        return VideoStreamingCodec._MAP.H265;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get Theora () {\n        return VideoStreamingCodec._MAP.Theora;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VP8 () {\n        return VideoStreamingCodec._MAP.VP8;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VP9 () {\n        return VideoStreamingCodec._MAP.VP9;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return VideoStreamingCodec._valueForKey(key, VideoStreamingCodec._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return VideoStreamingCodec._keyForValue(value, VideoStreamingCodec._MAP);\n    }\n}\n\nVideoStreamingCodec._MAP = Object.freeze({\n    /**\n     * A block-oriented motion-compensation-based video compression standard. As of 2014 it is one\n     * of the most commonly used formats for the recording, compression, and distribution of video\n     * content.\n     */\n    'H264': 'H264',\n    /**\n     * High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video\n     * compression standard, one of several potential successors to the widely used AVC\n     * (H.264 or MPEG-4 Part 10). In comparison to AVC, HEVC offers about double the data\n     * compression ratio at the same level of video quality, or substantially improved video quality\n     * at the same bit rate. It supports resolutions up to 8192x4320, including 8K UHD.\n     */\n    'H265': 'H265',\n    /**\n     * Theora is derived from the formerly proprietary VP3 codec, released into the public domain by\n     * On2 Technologies. It is broadly comparable in design and bitrate efficiency to MPEG-4 Part 2,\n     * early versions of Windows Media Video, and RealVideo while lacking some of the features\n     * present in some of these other codecs. It is comparable in open standards philosophy to the\n     * BBC's Dirac codec.\n     */\n    'Theora': 'Theora',\n    /**\n     * VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and\n     * Opus audio. The image format WebP is based on VP8's intra-frame coding. VP8's direct\n     * successor, VP9, and the emerging royalty-free internet video format AV1 from the Alliance\n     * for Open Media (AOMedia) are based on VP8.\n     */\n    'VP8': 'VP8',\n    /**\n     * Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video\n     * (UHD) and also enables lossless compression.\n     */\n    'VP9': 'VP9',\n});\n\nexport { VideoStreamingCodec };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VideoStreamingProtocol } from '../enums/VideoStreamingProtocol.js';\nimport { VideoStreamingCodec } from '../enums/VideoStreamingCodec.js';\n\nclass VideoStreamingFormat extends RpcStruct {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n    /**\n    * @param {VideoStreamingProtocol} val\n    * @return {VideoStreamingFormat}\n    */\n    setProtocol (val) {\n        this.validateType(VideoStreamingProtocol, val);\n        this.setParameter(VideoStreamingFormat.KEY_PROTOCOL, val);\n        return this;\n    }\n\n    /**\n    * @return {VideoStreamingProtocol}\n    */\n    getProtocol () {\n        return this.getParameter(VideoStreamingFormat.KEY_PROTOCOL);\n    }\n\n    /**\n    * @param {VideoStreamingCodec} val\n    * @return {VideoStreamingFormat}\n    */\n    setCodec (val) {\n        this.validateType(VideoStreamingCodec, val);\n        this.setParameter(VideoStreamingFormat.KEY_CODEC, val);\n        return this;\n    }\n\n    /**\n    * @return {VideoStreamingCodec}\n    */\n    getCodec () {\n        return this.getParameter(VideoStreamingFormat.KEY_CODEC);\n    }\n}\n\nVideoStreamingFormat.KEY_PROTOCOL = 'protocol';\nVideoStreamingFormat.KEY_CODEC = 'codec';\n\nexport { VideoStreamingFormat };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { MessageFrameDisassembler } from './MessageFrameDisassembler.js';\nimport { TransportListener } from '../transport/TransportListener.js';\nimport { Version } from '../util/Version.js';\nimport { ServiceType } from './enums/ServiceType.js';\nimport { FrameType } from './enums/FrameType.js';\nimport { MessageFrameAssembler } from './MessageFrameAssembler.js';\nimport { SdlPacket } from './SdlPacket.js';\nimport { ControlFrameTags } from './enums/ControlFrameTags.js';\nimport { BitConverter } from './../util/BitConverter.js';\n\nimport { SdlPacketFactory } from './SdlPacketFactory.js';\nimport { RpcCreator } from './../rpc/RpcCreator.js';\nimport { ImageResolution } from '../rpc/structs/ImageResolution.js';\nimport { VideoStreamingFormat } from '../rpc/structs/VideoStreamingFormat.js';\n\n/**\n * Base implementation of sdl protocol.\n * Should be able to handle basic control frames and be able to\n * send and receive packets from the transport manager.\n * Also sends key events to the sdlProtocolListener.\n */\nclass SdlProtocolBase {\n    /**\n     *\n     * @param { TransportConfigBase } baseTransportConfig\n     * @param { SdlProtocolListener } sdlProtocolListener\n     * @constructor\n     */\n    constructor (baseTransportConfig, sdlProtocolListener) {\n        this._baseTransportConfig = baseTransportConfig;\n        this._transportConfig = baseTransportConfig;\n        this._sdlProtocolListener = sdlProtocolListener;\n        this._transportManager = null;\n\n        this._reset();\n        this._createTransportListener();\n    }\n\n\n    /**\n     * Resets the sdl protocol to its default state.\n     * @private\n     */\n    _reset () {\n        this._protocolVersion = new Version(1, 0, 0);\n        this._transportConfig = this._baseTransportConfig;\n        this._headerSize = SdlProtocolBase.V1_HEADER_SIZE;\n        this._serviceStatus = {};\n        this._serviceStatus[ServiceType.CONTROL] = true;\n        this._mtus = {};\n        this._mtus[ServiceType.RPC] = SdlProtocolBase.V1_V2_MTU_SIZE - this._headerSize;\n        this._hashID = 0;\n        this._messageFrameAssemblers = {};\n        this._messageID = 1;\n        this._sessionID = 0;\n    }\n\n\n    /**\n     * Sets a transport manager.\n     * @param { TransportManagerBase } manager\n     */\n    setTransportManager (manager) {\n        if (!this._serviceStatus[ServiceType.RPC]) {\n            // RPC service hasn't been started, lets start it\n            this.startService(ServiceType.RPC, 0, false);\n        }\n        this._transportManager = manager;\n    }\n\n\n    /**\n     * Creates the transport listener. This will recieve incoming requests\n     * from the transport manager.\n     */\n    _createTransportListener () {\n        const self = this;\n        this._transportListener = new TransportListener();\n        this._transportListener.setOnTransportConnected(function () {\n            self._handleTransportConnected();\n        });\n        this._transportListener.setOnTransportDisconnected(function () {\n        });\n        this._transportListener.setOnPacketReceived(function (sdlPacket) {\n            self._handlePacketReceived(sdlPacket);\n        });\n        this._transportListener.setOnError(function () {\n        });\n    }\n\n    _handleTransportConnected () {\n        this._sdlProtocolListener.onTransportConnected();\n    }\n\n    /**\n     * Starts up the SDL protocol class. It will kick off the transport manager and underlying transport.\n     */\n    start () {\n        if (!this._transportManager) {\n            throw new Error('A transport manager must be defined, unable to start SDL Protocol');\n        }\n        this._transportManager.start();\n    }\n\n\n    /**\n     * Start the service. This is the first step in communicating with sdl core.\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID\n     * @param {Boolean} isEncrypted\n     */\n    startService (serviceType, sessionID, isEncrypted) {\n        const protocolVersion = this.constructor.MAX_PROTOCOL_VERSION;\n        const messageID = 0;\n        const header = new SdlPacket(protocolVersion.getMajor(), isEncrypted, FrameType.CONTROL,\n            serviceType, SdlPacket.FRAME_INFO_START_SERVICE, sessionID,\n            0, messageID, null);\n        if (serviceType === ServiceType.AUDIO) {\n            return this.sendPacket(header);\n        } else if (serviceType === ServiceType.RPC) {\n            header.putTag(ControlFrameTags.RPC.StartService.PROTOCOL_VERSION, protocolVersion.toString());\n        } else if (serviceType === ServiceType.VIDEO) {\n            if (this._sdlProtocolListener !== null) {\n                const videoStreamingParameters = this._sdlProtocolListener.getDesiredVideoParams();\n                if (videoStreamingParameters !== null) {\n                    const desiredResolution = videoStreamingParameters.getResolution();\n                    const desiredFormat = videoStreamingParameters.getFormat();\n                    if (desiredResolution) {\n                        header.putTag(ControlFrameTags.Video.StartService.WIDTH, desiredResolution.getResolutionWidth());\n                        header.putTag(ControlFrameTags.Video.StartService.HEIGHT, desiredResolution.getResolutionHeight());\n                    }\n                    if (desiredFormat) {\n                        header.putTag(ControlFrameTags.Video.StartService.VIDEO_CODEC, desiredFormat.getCodec());\n                        header.putTag(ControlFrameTags.Video.StartService.VIDEO_PROTOCOL, desiredFormat.getProtocol());\n                    }\n                }\n            }\n            return this.sendPacket(header);\n        } else {\n            throw new Error('Service type not implemented');\n        }\n        this.sendPacket(header);\n    }\n\n    /**\n     *  Get the max transport unit of a specific service type.\n     * @param { ServiceType } serviceType\n     * @return {number} max transport unit for the given service type\n     */\n    getMtu (serviceType) {\n        const retVal = this._mtus[serviceType];\n        if (retVal) {\n            return retVal;\n        }\n        return SdlProtocolBase.V1_V2_MTU_SIZE;\n    }\n\n    /**\n     * Returns true if transport manager is connected.\n     * @return {Boolean} isConnected\n     */\n    isConnected () {\n        return this._transportManager && this._transportManager.isConnected(null, null);\n    }\n\n    /**\n     * Get the current protocol version in use.\n     * @returns {Version} protocol version\n     */\n    getProtocolVersion () {\n        return this._protocolVersion;\n    }\n\n\n    /**\n     * This method will set the major protocol version that we should use.\n     * It will also set the default MTU based on version.\n     * @param { number } version major version to use\n     */\n    _setVersion (version) {\n        if (version > 5) {\n            this._protocolVersion = new Version('5.1.0'); // protect for future, proxy only supports v5 or lower\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE;\n        } else if (version === 5) {\n            this._protocolVersion = new Version('5.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE;\n        } else if (version === 4) {\n            this._protocolVersion = new Version('4.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE; // versions 4 supports 128k MTU\n        } else if (version === 3) {\n            this._protocolVersion = new Version('3.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE; // versions 3 supports 128k MTU\n        } else if (version === 2) {\n            this._protocolVersion = new Version('2.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V1_V2_MTU_SIZE - this.headerSize;\n        } else if (version === 1) {\n            this._protocolVersion = new Version('1.0.0');\n            this.headerSize = this.constructor.V1_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V1_V2_MTU_SIZE - this.headerSize;\n        }\n    }\n\n    /**\n     * Sends an sdlPacket.\n     * @param {SdlPacket} sdlPacket\n     */\n    sendPacket (sdlPacket) {\n        if (this._transportManager) {\n            this._transportManager.sendPacket(sdlPacket);\n        }\n    }\n\n    /**\n     * Returns the sessionId in use.\n     * @returns {Number}\n     */\n    _getSessionId () {\n        return this._sdlProtocolListener.getSessionId();\n    }\n\n    /**\n     * Gets the next available messageID for sending requests.\n     * @returns {Number}\n     */\n    _getNextMessageID () {\n        return this._messageID++;\n    }\n\n    /**\n     * Takes an rpc message and sends a single or multi frame packets.\n     * @param {RpcRequest} rpcMessage\n     */\n    sendRpc (rpcRequest) {\n        const self = this;\n        const sessionId = this._getSessionId();\n        const messageID = this._getNextMessageID();\n        const mtu = self._mtus[ServiceType.RPC];\n        const version = self._protocolVersion.getMajor();\n        const isEncrypted = rpcRequest.getIsEncrypted();\n\n        MessageFrameDisassembler.buildRPC(rpcRequest, sessionId, messageID, mtu, version, isEncrypted, function (sdlPacket) {\n            self.sendPacket(sdlPacket);\n        });\n    }\n\n    /**\n     * Handles incoming packets.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handlePacketReceived (sdlPacket) {\n        if (this._protocolVersion === null || this._protocolVersion.getMajor() === 1) {\n            this._setVersion(sdlPacket.getVersion());\n        }\n        const frameType = sdlPacket.getFrameType();\n        if (frameType === FrameType.CONTROL) {\n            return this._handleControlPacket(sdlPacket);\n        } else {\n            const messageFrameAssembler = this._getMessageFrameAssembler(sdlPacket);\n            return messageFrameAssembler.handleFrame(sdlPacket);\n        }\n    }\n\n    /**\n     * Handles non-control packets after they have been assembled.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleOnMessageAssembled (sdlPacket) {\n        const serviceType = sdlPacket.getServiceType();\n\n        if (serviceType === ServiceType.RPC || serviceType === ServiceType.HYBRID) {\n            return this._handleRPCPacket(sdlPacket);\n        } else if (serviceType === ServiceType.HYBRID) {\n            return this._handleRPCPacket(sdlPacket);\n        } else {\n            console.warn('Unhandled service type ', sdlPacket);\n        }\n    }\n\n    /**\n     * Get the message frame assembler for the packet.\n     * @param {SdlPacket} sdlPacket\n     */\n    _getMessageFrameAssembler (sdlPacket) {\n        const self = this;\n        let messageFrameAssembler = self._messageFrameAssemblers[sdlPacket.getMessageID()];\n        if (!messageFrameAssembler) {\n            messageFrameAssembler = new MessageFrameAssembler(function (err, sdlPacket) {\n                if (err) {\n                    throw new Error(err);\n                }\n                self._messageFrameAssemblers[sdlPacket.getMessageID()] = null; // Remove the mapping\n                self._handleOnMessageAssembled(sdlPacket);\n            });\n            self._messageFrameAssemblers[sdlPacket.getMessageID()] = messageFrameAssembler;\n        }\n\n        return messageFrameAssembler;\n    }\n\n    /**\n     * Handles incoming control packets.\n     * @param { SdlPacket } sdlPacket\n     */\n    _handleControlPacket (sdlPacket) {\n        const frameInfo = sdlPacket.getFrameInfo();\n\n        if (frameInfo === SdlPacket.FRAME_INFO_HEART_BEAT) {\n            return this._handleProtocolHeartbeat(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_HEART_BEAT_ACK) {\n            return this._handleProtocolHeartbeatACK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_START_SERVICE_ACK) {\n            return this._handleStartServiceACK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_START_SERVICE_NAK) {\n            return this._handleStartServiceNAK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_END_SERVICE_ACK) {\n            return this._handleEndServiceACK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_END_SERVICE) {\n            return this._handleEndService(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_END_SERVICE_NAK) {\n            return this._handleEndServiceNAK(sdlPacket);\n        } else {\n            console.warn('Unhandled control packet', { frameInfo });\n        }\n    }\n\n\n    /**\n     * Handle heartbeat (Only available in protocol version 3)\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleProtocolHeartbeat (sdlPacket) {\n        const heartbeat = SdlPacketFactory.createHeartbeatACK(\n            ServiceType.CONTROL,\n            this._getSessionId(),\n            this._protocolVersion.getMajor());\n        this.sendPacket(heartbeat);\n    }\n\n    /**\n     * Handles heartbeat ACK.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleProtocolHeartbeatACK (sdlPacket) {\n        console.log(`Received HeartbeatACK - ${sdlPacket.toString()}`);\n    }\n\n    /**\n     * Handles start service ACK. Sets the appropriate version, MTU, and other\n     * service related info.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleStartServiceACK (sdlPacket) {\n        const version = sdlPacket.getVersion();\n        const serviceType = sdlPacket.getServiceType();\n        if (version >= 5) {\n            let mtuTag = null;\n            if (serviceType === ServiceType.RPC) {\n                mtuTag = ControlFrameTags.RPC.StartServiceACK.MTU;\n            } else if (serviceType === (ServiceType.PCM)) {\n                mtuTag = ControlFrameTags.Audio.StartServiceACK.MTU;\n            } else if (serviceType === (ServiceType.NAV)) {\n                mtuTag = ControlFrameTags.Video.StartServiceACK.MTU;\n            }\n            const mtu = sdlPacket.getTag(mtuTag);\n\n            if (mtu !== null) {\n                this._mtus[serviceType] = mtu;\n            }\n            if (serviceType === ServiceType.RPC) {\n                this._sessionID = sdlPacket.getSessionID();\n                // TODO handle older versions of the protocol where this was just their payload, no BSON\n                this._hashID = sdlPacket.getTag(ControlFrameTags.RPC.StartServiceACK.HASH_ID);\n                const version = sdlPacket.getTag(ControlFrameTags.RPC.StartServiceACK.PROTOCOL_VERSION);\n                if (version) {\n                    // At this point we have confirmed the negotiated version between the module and the proxy\n                    this._protocolVersion = (new Version()).fromString(version);\n                } else {\n                    this._protocolVersion = new Version(5, 0, 0);\n                }\n            } else if (serviceType === ServiceType.VIDEO) {\n                if (this._sdlProtocolListener !== null) {\n                    const acceptedResolution = new ImageResolution();\n                    const acceptedFormat = new VideoStreamingFormat();\n                    acceptedResolution.setResolutionHeight(Math.floor(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.HEIGHT)));\n                    acceptedResolution.setResolutionWidth(Math.floor(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.WIDTH)));\n\n                    acceptedFormat.setCodec(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.VIDEO_CODEC));\n                    acceptedFormat.setProtocol(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.VIDEO_PROTOCOL));\n                    const agreedVideoParams = this._sdlProtocolListener.getDesiredVideoParams();\n                    agreedVideoParams.setResolution(acceptedResolution);\n                    agreedVideoParams.setFormat(acceptedFormat);\n\n                    this._sdlProtocolListener.setAcceptedVideoParams(agreedVideoParams);\n                }\n            }\n        } else {\n            if (this._protocolVersion.getMajor() > 1) {\n                const payload = sdlPacket.getPayload();\n                if (payload !== null && payload.length === 4) { // hashid will be 4 bytes in length\n                    this._hashID = BitConverter.arrayBufferToInt32(payload.buffer);\n                }\n            }\n        }\n\n        this._sdlProtocolListener.onProtocolSessionStarted(serviceType,\n            sdlPacket.getSessionID(), this._protocolVersion.getMajor(), '', this._hashID, sdlPacket.getEncryption());\n    }\n\n    /**\n     * Handles start service rejection.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleStartServiceNAK (sdlPacket) {\n        const error = `Got StartSessionNACK for protocol sessionID ${sdlPacket.getSessionID()}`;\n        throw new Error(error);\n    }\n\n\n    /**\n     * Handles service ended by app process.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleEndServiceACK (sdlPacket) {\n        return this._handleServiceEnded(sdlPacket);\n    }\n\n    /**\n     * Service ended by non app process or for some unexpected reason.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleEndService (sdlPacket) {\n        return this._handleServiceEnded(sdlPacket);\n    }\n\n\n    /**\n     * Handles serivce ending.\n     * @param {*} sdlPacket\n     */\n    _handleServiceEnded (sdlPacket) {\n        this._sdlProtocolListener.onProtocolSessionEnded(sdlPacket.getServiceType(), sdlPacket.getSessionID(), '');\n    }\n\n    /**\n     * Handles service end rejection.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleEndServiceNAK (sdlPacket) {\n        const serviceType = sdlPacket.getServiceType();\n        const protocolVersion = sdlPacket.getVersion();\n        if (protocolVersion >= 5) {\n            let rejectedTag = null;\n            if (serviceType === ServiceType.AUDIO) {\n                rejectedTag = ControlFrameTags.Audio.EndServiceNAK.REJECTED_PARAMS;\n            } else if (serviceType === ServiceType.VIDEO) {\n                rejectedTag = ControlFrameTags.Video.EndServiceNAK.REJECTED_PARAMS;\n            }\n            const rejectedParams = sdlPacket.getTag(rejectedTag);\n            if (Array.isArray(rejectedParams) && rejectedParams.length > 0) {\n                console.error('Got EndSessionNAK with rejected params', rejectedParams);\n            }\n        }\n        this._sdlProtocolListener.onProtocolSessionEndedNACKed(serviceType, sdlPacket.getSessionID(), '');\n    }\n\n    /**\n     * Handles incoming assembled rpc packet.\n     * Notifies sdlProtocolListener of the event after assembleing an RpcMessage\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleRPCPacket (sdlPacket) {\n        const rpcMessage = RpcCreator.construct(sdlPacket);\n        if (rpcMessage !== null) {\n            this._sdlProtocolListener.onRpcMessageReceived(rpcMessage);\n        }\n    }\n\n    /**\n     * Ends the default session.\n     */\n    endSession () {\n        const sessionId = this._getSessionId();\n        const hashID = this._hashID;\n        const serviceType = ServiceType.RPC;\n        const messageID = this._getNextMessageID();\n        const version = this._protocolVersion.getMajor();\n        const sdlPacket = SdlPacketFactory.createEndSession(serviceType, sessionId, messageID, version, hashID);\n        this.sendPacket(sdlPacket);\n    }\n\n    /**\n     * Ends a specific service\n     * @param {ServiceType} serviceType - Service type being ended. When the RPC service is ended the entire session ends.\n     * @param {Number} sessionId - represents a byte\n     */\n    endService (serviceType, sessionId) {\n        if (serviceType === ServiceType.RPC) {\n            return this.endSession();\n        } else {\n            const hashID = this._hashID;\n            const messageID = this._getNextMessageID();\n            const version = this._protocolVersion.getMajor();\n            const sdlPacket = SdlPacketFactory.createEndSession(serviceType, sessionId, messageID, version, hashID);\n            this.sendPacket(sdlPacket);\n        }\n    }\n}\n\n/**\n * Original header size based on version 1.0.0 only\n */\nSdlProtocolBase.V1_HEADER_SIZE = 8;\n/**\n * Larger header size that is used by versions 2.0.0 and up\n */\nSdlProtocolBase.V2_HEADER_SIZE = 12;\n\nSdlProtocolBase.V1_V2_MTU_SIZE = 1500;\nSdlProtocolBase.V3_V4_MTU_SIZE = 131072;\n\n/**\n * Max supported protocol version in this release of the library\n*/\nSdlProtocolBase.MAX_PROTOCOL_VERSION = new Version(5, 2, 0);\n\nexport { SdlProtocolBase };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TransportType\n * @property {Object} _MAP\n */\nclass TransportType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @param {String}\n    */\n    static get WEBSOCKET_CLIENT () {\n        return TransportType._MAP.WEBSOCKET_CLIENT;\n    }\n\n    /**\n    * @param {String}\n    */\n    static get WEBSOCKET_SERVER () {\n        return TransportType._MAP.WEBSOCKET_SERVER;\n    }\n\n    /**\n    * @param {String}\n    */\n    static get CUSTOM () {\n        return TransportType._MAP.CUSTOM;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return TransportType._valueForKey(key, TransportType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return TransportType._keyForValue(value, TransportType._MAP);\n    }\n}\n\nTransportType._MAP = Object.freeze({\n    'WEBSOCKET_CLIENT': 'WEBSOCKET_CLIENT',\n    'WEBSOCKET_SERVER': 'WEBSOCKET_SERVER',\n    'CUSTOM': 'CUSTOM',\n});\n\nexport { TransportType };","/*\n * Copyright (c) 2019, Livio, Inc.\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided with the\n * distribution.\n *\n * Neither the name of the Livio Inc. nor the names of its contributors\n * may be used to endorse or promote products derived from this software\n * without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport { FrameType } from '../protocol/enums/FrameType.js';\nimport { SdlPacket } from '../protocol/SdlPacket.js';\nimport { SdlProtocolBase } from '../protocol/SdlProtocolBase.js';\n\n/**\n * Parses incoming bytes according to the protocol spec.\n */\nclass SdlPsm {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this.reset();\n    }\n\n    /**\n     * Changes all internal members to default\n     */\n    reset () {\n        this._state = SdlPsm.START_STATE;\n        this._version = 0;\n        this._encryption = false;\n        this._frameType = FrameType.SINGLE;\n        this._serviceType = 0;\n        this._controlFrameInfo = null;\n        this._sessionID = null;\n        this._dumpSize = null;\n        this._dataLength = 0;\n        this._messageID = 0;\n        this._payload = null;\n    }\n\n\n\n    /**\n     * @return {Number} - State represented by a Number\n     */\n    getState () {\n        return this._state;\n    }\n\n    /**\n     * @return {SdlPacket} - Returns null if not complete\n     */\n\n    getFormedPacket () {\n        if (this._state === SdlPsm.FINISHED_STATE) {\n            return new SdlPacket(this._version, this._encryption, this._frameType, this._serviceType, this._controlFrameInfo, this._sessionID, this._dataLength, this._messageID, this._payload, 0, this._dataLength);\n        } else {\n            return null;\n        }\n    }\n\n    /**\n     * Handles the next byte in the stream of data.\n     * @param {Number} data - Represents a byte\n     * @return {Boolean} - True if successful, false otherwise\n     */\n    handleByte (data) {\n        this._state = this._transitionOnInput(data, this._state);\n        if (this._state === SdlPsm.ERROR_STATE) {\n            return false;\n        }\n        return true;\n    }\n\n    /**\n     * @param {Number} rawByte - Represents a byte\n     * @param {Number} state\n     * @return {Boolean}\n     * @private\n     */\n    _transitionOnInput (rawByte, state) {\n        if (state === SdlPsm.START_STATE) { // byte 1\n            this._version = (rawByte & SdlPsm.VERSION_MASK) >> 4;\n            if (this._version === 0) {\n                return SdlPsm.ERROR_STATE;\n            }\n\n            this._encryption = (1 === ((rawByte & SdlPsm.ENCRYPTION_MASK) >> 3));\n            this._frameType = rawByte & SdlPsm.FRAME_TYPE_MASK;\n\n            if ((this._version < 1 || this._version > 5) && this._frameType !== FrameType.CONTROL) {\n                return SdlPsm.ERROR_STATE;\n            }\n\n            if (this._frameType < FrameType.CONTROL || this._frameType > FrameType.CONSECUTIVE) {\n                return SdlPsm.ERROR_STATE;\n            }\n            return SdlPsm.SERVICE_TYPE_STATE;\n        } else if (state === SdlPsm.SERVICE_TYPE_STATE) { // byte 2\n            this._serviceType = (rawByte & 0xFF);\n\n            return SdlPsm.CONTROL_FRAME_INFO_STATE;\n        } else if (state === SdlPsm.CONTROL_FRAME_INFO_STATE) { // byte 3\n            this._controlFrameInfo = rawByte & 0xFF;\n\n            switch (this._frameType) {\n                case FrameType.CONTROL:\n                    break;\n                case FrameType.SINGLE: // Fall through since they are both the same\n                case FrameType.FIRST:\n                    if (this._controlFrameInfo !== 0x00) {\n                        return SdlPsm.ERROR_STATE;\n                    }\n                    break;\n                case FrameType.CONSECUTIVE:\n                    break;\n\n                default:\n                    return SdlPsm.ERROR_STATE;\n            }\n            return SdlPsm.SESSION_ID_STATE;\n        } else if (state === SdlPsm.SESSION_ID_STATE) { // byte 4\n            this._sessionID = (rawByte & 0xFF);\n            return SdlPsm.DATA_SIZE_1_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_1_STATE) { // byte 5\n            this._dataLength += (rawByte & 0xFF) << 24;\n            return SdlPsm.DATA_SIZE_2_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_2_STATE) { // byte 6\n            this._dataLength += (rawByte & 0xFF) << 16; // # 2 bytes x 8 bits\n            return SdlPsm.DATA_SIZE_3_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_3_STATE) { // byte 7\n            this._dataLength += (rawByte & 0xFF) << 8; // #  1 byte x 8 bits\n            return SdlPsm.DATA_SIZE_4_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_4_STATE) { // byte 8\n            this._dataLength += (rawByte & 0xFF); // # 2 bytes x 8 bits\n\n            switch (this._frameType) { // If all is correct we should break out of this switch statement\n                case FrameType.SINGLE:\n                case FrameType.CONSECUTIVE:\n                    break;\n                case FrameType.CONTROL:\n                // Ok, well here's some interesting bit of knowledge. Because the start session request is from the phone with no knowledge of version it sends out\n                // a v1 packet. THEREFORE there is no message id field. **** Now you know and knowing is half the battle ****\n                    if (this._version === 1 && this._controlFrameInfo === SdlPacket.FRAME_INFO_START_SERVICE) {\n                        if (this._dataLength === 0) {\n                            return SdlPsm.FINISHED_STATE; // We are done if we don't have any payload\n                        }\n                        if (this._dataLength <= SdlProtocolBase.V1_V2_MTU_SIZE - SdlProtocolBase.V1_HEADER_SIZE) {\n                            this._payload = new Uint8Array(this._dataLength);\n                        } else {\n                            return SdlPsm.ERROR_STATE;\n                        }\n                        this._dumpSize = this._dataLength;\n                        return SdlPsm.DATA_PUMP_STATE;\n                    }\n                    break;\n\n                case FrameType.FIRST:\n                    if (this._dataLength !== SdlPsm.FIRST_FRAME_DATA_SIZE) {\n                        return SdlPsm.ERROR_STATE;\n                    }\n                    break;\n                default:\n                    return SdlPsm.ERROR_STATE;\n            }\n\n            if (this._version === 1) { // Version 1 packets will not have message id's\n                if (this._dataLength === 0) {\n                    return SdlPsm.FINISHED_STATE; // We are done if we don't have any payload\n                }\n                if (this._dataLength <= SdlProtocolBase.V1_V2_MTU_SIZE - SdlProtocolBase.V1_HEADER_SIZE) {\n                    this._payload = new Uint8Array(this._dataLength);\n                } else {\n                    return SdlPsm.ERROR_STATE;\n                }\n                this._dumpSize = this._dataLength;\n                return SdlPsm.DATA_PUMP_STATE;\n            } else {\n                return SdlPsm.MESSAGE_1_STATE;\n            }\n        } else if (state === SdlPsm.MESSAGE_1_STATE) { // byte 9, bytes 9-12 available in version 2+.\n            this._messageID += (rawByte & 0xFF) << 24;\n            return SdlPsm.MESSAGE_2_STATE;\n        } else if (state === SdlPsm.MESSAGE_2_STATE) { // byte 10\n            this._messageID += (rawByte & 0xFF) << 16;\n            return SdlPsm.MESSAGE_3_STATE;\n        } else if (state === SdlPsm.MESSAGE_3_STATE) { // byte 11\n            this._messageID += (rawByte & 0xFF) << 8;\n            return SdlPsm.MESSAGE_4_STATE;\n        } else if (state === SdlPsm.MESSAGE_4_STATE) { // byte 12\n            this._messageID += (rawByte & 0xFF);\n            if (this._dataLength === 0) {\n                return SdlPsm.FINISHED_STATE;\n            }\n            this._dumpSize = this._dataLength;\n            this._payload = new Uint8Array(this._dataLength);\n            return SdlPsm.DATA_PUMP_STATE;\n        } else if (state === SdlPsm.DATA_PUMP_STATE) { // byte 13\n            this._payload[this._dataLength - this._dumpSize] = rawByte;\n            this._dumpSize -= 1;\n            // Do we have any more bytes to read in?\n            if (this._dumpSize > 0) {\n                return SdlPsm.DATA_PUMP_STATE;\n            } else if (this._dumpSize === 0) {\n                return SdlPsm.FINISHED_STATE;\n            } else {\n                return SdlPsm.ERROR_STATE;\n            }\n        }\n    }\n}\n\nSdlPsm.START_STATE                              = 0x0;\nSdlPsm.SERVICE_TYPE_STATE                       = 0x02;\nSdlPsm.CONTROL_FRAME_INFO_STATE                 = 0x03;\nSdlPsm.SESSION_ID_STATE                         = 0x04;\nSdlPsm.DATA_SIZE_1_STATE                        = 0x05;\nSdlPsm.DATA_SIZE_2_STATE                        = 0x06;\nSdlPsm.DATA_SIZE_3_STATE                        = 0x07;\nSdlPsm.DATA_SIZE_4_STATE                        = 0x08;\nSdlPsm.MESSAGE_1_STATE                          = 0x09;\nSdlPsm.MESSAGE_2_STATE                          = 0x0A;\nSdlPsm.MESSAGE_3_STATE                          = 0x0B;\nSdlPsm.MESSAGE_4_STATE                          = 0x0C;\nSdlPsm.DATA_PUMP_STATE                          = 0x0D;\nSdlPsm.FINISHED_STATE                           = 0xFF;\nSdlPsm.ERROR_STATE                              = -1;\n\nSdlPsm.FIRST_FRAME_DATA_SIZE                    = 0x08;\nSdlPsm.VERSION_MASK                             = 0xF0; // 4 highest bits\nSdlPsm.ENCRYPTION_MASK                          = 0x08; // 4th lowest bit\nSdlPsm.FRAME_TYPE_MASK                          = 0x07; // 3 lowest bits\n\nexport { SdlPsm };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SdlPsm } from './SdlPsm.js';\n\nclass TransportBase {\n    /**\n     * @constructor\n     * @param {BaseTransportConfig} transportConfig\n     * @param {TransportCallback} transportCallback\n     */\n    constructor (transportConfig, transportCallback) {\n        this._sdlPsm = new SdlPsm();\n        this._transportConfig = transportConfig;\n        this._transportCallback = transportCallback;\n    }\n\n    start () {\n        throw new Error('start method must be overridden');\n    }\n\n    stop () {\n        throw new Error('stop method must be overridden');\n    }\n\n    /**\n     * @param {SdlPacket} sdlPacket\n     */\n    sendPacket (sdlPacket) {\n        throw new Error('sendPacket method must be overridden');\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        throw new Error('setTransportCallback method must be overridden');\n    }\n}\n\nexport { TransportBase };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportBase } from './TransportBase.js';\nimport { SdlPsm } from './SdlPsm.js';\n\nclass WebSocketClient extends TransportBase {\n    constructor (config, transportCallback) {\n        super(config, transportCallback);\n        this._queue = [];\n        this._isRunning = false;\n        this._wsUrl = `${config.getHost()}:${config.getPort()}`;\n        this._ws = null;\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        this._transportCallback = callback;\n    }\n\n    /**\n     * Opens the transport connection\n     */\n    start () {\n        this._init();\n    }\n\n    /**\n     * Initiates a websocket connection to the url passed in and listens for messages\n     * @private\n     */\n    _init () {\n        this._ws  = new WebSocket(this._wsUrl);\n\n        this._ws.onopen = () => {\n            this._transportCallback.onConnectionEstablished();\n        };\n\n        this._ws.onerror = (error) => {\n            console.error('Failed to connect', error);\n            this._transportCallback.onError();\n        };\n\n        this._ws.onmessage = (msg) => {\n            this._handleIncoming(msg);\n        };\n\n        this._ws.onclose = () => {\n            this._transportCallback.onConnectionTerminated();\n        };\n    }\n\n    /**\n     * Closes the transport connection\n     */\n    stop () {\n        this._ws.close();\n    }\n\n    /**\n     * The contents in the packet should be sent out through the transport\n     * @param {SdlPacket} packet\n     */\n    sendPacket (packet) {\n        const bytes = packet.toPacket();\n        this._ws.send(bytes);\n    }\n\n    /**\n     * This is called whenever a new message comes in\n     * @param {MessageEvent} msg\n     * @private\n     */\n    _handleIncoming (msg) {\n        this._queue.push(msg.data);\n        this._multiByteHandler();\n    }\n\n    /**\n     * Processes received data from the internal queue\n     * @private\n     */\n    _multiByteHandler () {\n        if (this._isRunning) {\n            return;\n        }\n        this._isRunning = true;\n\n        while (this._queue.length > 0) {\n            const msgData = this._queue.shift();\n            new Response(msgData).arrayBuffer().then((arrayBuffer) => {\n                const uint8 = new Uint8Array(arrayBuffer);\n                for (const byte of uint8) {\n                    this._handleByte(byte);\n                }\n            });\n        }\n\n        this._isRunning = false;\n    }\n\n    /**\n     * Feeds a byte through the internal PSM\n     * @param {Number} byte - unsigned 8-bit integer\n     * @private\n     */\n    _handleByte (byte) {\n        const success = this._sdlPsm.handleByte(byte);\n        if (!success) {\n            console.error('failed', this._sdlPsm);\n            this._sdlPsm.reset();\n        }\n        const isFinished = this._sdlPsm.getState() === SdlPsm.FINISHED_STATE;\n\n        if (isFinished) {\n            const packet = this._sdlPsm.getFormedPacket();\n            this._sdlPsm.reset();\n            this._transportCallback.onPacketReceived(packet);\n        }\n    }\n}\n\n\nexport { WebSocketClient };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass TransportCallback {\n    constructor () {\n        this._onConnectionEstablished = null;\n        this._onError = null;\n        this._onConnectionTerminated = null;\n        this._onPacketReceived = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnConnectionEstablished (listener) {\n        this._onConnectionEstablished = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnError (listener) {\n        this._onError = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnConnectionTerminated (listener) {\n        this._onConnectionTerminated = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnPacketReceived (listener) {\n        this._onPacketReceived = listener;\n    }\n\n    /**\n     * Handler for when a connection is successful\n     */\n    onConnectionEstablished () {\n        if (typeof this._onConnectionEstablished === 'function') {\n            this._onConnectionEstablished();\n        }\n    }\n\n    /**\n     * Handler for when a connection is successful\n     */\n    onError () {\n        if (typeof this._onError === 'function') {\n            this._onError();\n        }\n    }\n\n    /**\n     * Handler for when a connection is dropped\n     * @param {String} reason\n     */\n    onConnectionTerminated (reason) {\n        if (typeof this._onConnectionTerminated === 'function') {\n            this._onConnectionTerminated(reason);\n        }\n    }\n\n    /**\n     * Handler for when a packet is received\n     * @param {SdlPacket} packet\n     */\n    onPacketReceived (packet) {\n        if (typeof this._onPacketReceived === 'function') {\n            this._onPacketReceived(packet);\n        }\n    }\n}\n\n\nexport { TransportCallback };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportType } from './enums/TransportType.js';\nimport { WebSocketClient } from './WebSocketClient.js';\nimport { TransportCallback } from './TransportCallback.js';\n\nclass TransportManagerBase {\n    /**\n     * @constructor\n     * @param {BaseTransportConfig} baseTransportConfig\n     * @param {TransportListener} transportListener\n     */\n    constructor (baseTransportConfig, transportListener) {\n        this._transportConfig = baseTransportConfig;\n        this._transportListener = transportListener;\n        this._transport = null;\n        this._isConnected = false;\n        this._transportCallback = new TransportCallback();\n\n        this._transportCallback.setOnConnectionEstablished(() => {\n            this._isConnected = true;\n            transportListener.onTransportConnected();\n        });\n        this._transportCallback.setOnConnectionTerminated(() => {\n            this._isConnected = false;\n        });\n        this._transportCallback.setOnPacketReceived(this.onPacketReceived.bind(this));\n\n        if (this._transportConfig.getTransportType() === TransportType.WEBSOCKET_CLIENT) {\n            this._transport = new WebSocketClient(this._transportConfig, this._transportCallback);\n        } else if (this._transportConfig.getTransportType() === TransportType.CUSTOM) {\n            this._transport = this._transportConfig.getTransport();\n            this._transport.setTransportCallback(this._transportCallback);\n        }\n    }\n\n    onTransportConnected () {\n        this._transportListener.onTransportConnected();\n    }\n\n    /**\n     * @param {Function} func\n     */\n    onTransportDisconnected (func) {\n        this._transportListener.onTransportDisconnected();\n    }\n\n    /**\n     * @param {Function} func\n     */\n    onError (func) {\n        this._transportListener.onError();\n    }\n\n    /**\n     * @param {SdlPacket} sdlPacket\n     */\n    onPacketReceived (sdlPacket) {\n        this._transportListener.onPacketReceived(sdlPacket);\n    }\n\n    /**\n     * Opens the transport connection\n     */\n    start () {\n        if (this._transport !== null && typeof this._transport.start === 'function') {\n            this._transport.start();\n        }\n    }\n\n    /**\n     * Closes the transport connection\n     */\n    stop () {\n        if (this._transport !== null && typeof this._transport.stop === 'function') {\n            this._transport.stop();\n        }\n    }\n\n    /**\n     * The contents in the packet should be sent out through the transport\n     * @param {SdlPacket} packet\n     */\n    sendPacket (packet) {\n        if (this._transport !== null && typeof this._transport.sendPacket === 'function') {\n            this._transport.sendPacket(packet);\n        }\n    }\n\n    /**\n     * @param {TransportType} transportType\n     * @param {String} address\n     */\n    isConnected (transportType, address) {\n        return this._isConnected;\n    }\n}\n\nexport { TransportManagerBase };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nconst { TransportBase } = require('./TransportBase.js');\nconst { SdlPsm } = require('./SdlPsm.js');\nconst WebSocket = require('ws');\n\nclass WebSocketServer extends TransportBase {\n    constructor (transportConfig, transportCallback = null) {\n        super(transportConfig, transportCallback);\n        this._connectionLostInterval = null;\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        this._transportCallback = callback;\n        return this;\n    }\n\n    /**\n     * Start listening for events from the client\n     * @return {WebSocketServer}\n     */\n    start () {\n        const client = this._transportConfig.getClient();\n        const connectionLostTimeout = this._transportConfig.getConnectionLostTimeout();\n\n        // Event listener for an incoming message\n        client.on('message', (message) => {\n            this._handleMessage(message);\n        });\n\n        // Event listener for a closed connection\n        client.on('close', () => {\n            console.log('server received close event');\n            this._stopConnectionLostInterval();\n            if (this._transportCallback !== null) {\n                this._transportCallback.onConnectionTerminated();\n            }\n        });\n\n        // Event listener for errors\n        client.on('error', (errorEvent) => {\n            console.log('server received error event');\n            if (this._transportCallback !== null) {\n                this._transportCallback.onError();\n            }\n        });\n\n        // Pong heartbeat listener\n        client.on('pong', () => {\n            console.log('server received pong event');\n            client.isAlive = true;\n        });\n\n        // Trigger event for connection established\n        if (this._transportCallback !== null) {\n            this._transportCallback.onConnectionEstablished();\n        }\n\n        // Detect broken connections\n        if (connectionLostTimeout > 0) {\n            this._connectionLostInterval = setInterval(() => {\n                if (client.isAlive === false) {\n                    console.log('server deemed client dead');\n                    return client.terminate();\n                }\n\n                // Assume the client is dead and ask it if it's alive\n                client.isAlive = false;\n                console.log('server sending ping to client');\n                client.ping(function () {});\n            }, connectionLostTimeout);\n        }\n\n        client.isAlive = true;\n\n        return this;\n    }\n\n    /**\n     * Stops the WebSocket Server from listening and closes existing connections\n     * @return {WebSocketServer}\n     */\n    stop () {\n        const client = this._transportConfig.getClient();\n\n        client.terminate();\n\n        return this;\n    }\n\n    /**\n     * Sends a packet to the connected WebSocket Server client\n     * @return {WebSocketServer}\n     */\n    sendPacket (sdlPacket) {\n        const client = this._transportConfig.getClient();\n        if (client.readyState === WebSocket.OPEN) {\n            client.send(sdlPacket.toPacket());\n        }\n\n        return this;\n    }\n\n    /**\n     * Stop the connection lost interval if one is defined\n     * @return {WebSocketServer}\n     * @private\n     */\n    _stopConnectionLostInterval () {\n        if (this._connectionLostInterval !== null) {\n            clearInterval(this._connectionLostInterval);\n        }\n\n        return this;\n    }\n\n    /**\n     * This is called whenever a new message comes in\n     * @param {MessageEvent} message\n     * @private\n     */\n    _handleMessage (message) {\n        // Require messages to be binary objects\n        if (typeof message !== 'object' || message.constructor.name !== 'Buffer') {\n            return;\n        }\n\n        // Parse the message\n        let stateProgress = false;\n        for (let messageIndex = 0; messageIndex < message.length; messageIndex++) {\n            stateProgress = this._sdlPsm.handleByte(message[messageIndex]);\n\n            if (!stateProgress) { // We are trying to weed through the bad packet info until we get something\n                this._sdlPsm.reset();\n            } else if (this._sdlPsm.getState() === SdlPsm.FINISHED_STATE) {\n                const packet = this._sdlPsm.getFormedPacket();\n                if (this._transportCallback !== null && packet !== null) {\n                    this._transportCallback.onPacketReceived(packet);\n                }\n\n                this._sdlPsm.reset();\n            }\n        }\n    }\n}\n\nmodule.exports = {\n    WebSocketServer,\n};","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nconst { TransportManagerBase } = require('./TransportManagerBase.js');\nconst { TransportType } = require('./enums/TransportType.js');\nconst { WebSocketServer } = require('./WebSocketServer.js');\n\nclass TransportManager extends TransportManagerBase {\n    constructor (transportConfig, transportListener) {\n        super(transportConfig, transportListener);\n\n        if (this._transportConfig.getTransportType() === TransportType.WEBSOCKET_SERVER) {\n            this._transport = new WebSocketServer(this._transportConfig, this._transportCallback);\n        } else if (this._transport === null) {\n            throw new Error('Unsupported transport type');\n        }\n    }\n}\n\n\nmodule.exports = {\n    TransportManager,\n};","\nimport { SdlProtocolBase } from './SdlProtocolBase.js';\nimport { TransportManager } from './../transport/TransportManager.js';\n\n\nclass SdlProtocol extends SdlProtocolBase {\n    /**\n     * @param {TransportConfigBase} baseTransportConfig\n     * @param {SdlProtocolListener} sdlProtocolListener\n     */\n    constructor (baseTransportConfig, sdlProtocolListener) {\n        super(baseTransportConfig, sdlProtocolListener);\n        this.setTransportManager(new TransportManager(this._transportConfig, this._transportListener));\n    }\n}\n\nexport { SdlProtocol };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ServiceType } from '../protocol/enums/ServiceType.js';\n\nclass ServiceListenerMap {\n    /**\n    * @constructor\n    */\n    constructor () {\n        this._listeners = {};\n\n        // initialize an array of listeners for each service type\n        this._listeners[ServiceType.CONTROL] = [];\n        this._listeners[ServiceType.RPC] = [];\n        this._listeners[ServiceType.AUDIO] = [];\n        this._listeners[ServiceType.VIDEO] = [];\n        this._listeners[ServiceType.HYBRID] = [];\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} serviceListener\n     */\n    addListener (serviceType, serviceListener) {\n        if (!serviceType) {\n            return;\n        }\n        this._listeners[serviceType].push(serviceListener);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} serviceListener\n     * @return {Boolean} - whether the service got removed\n     */\n    removeListener (serviceType, serviceListener) {\n        if (!serviceType) {\n            return;\n        }\n        const listenerArray = this._listeners[serviceType];\n        let removed = false;\n        // remove matching references to the passed in service listener\n        this._listeners[serviceType] = listenerArray.filter(listener => {\n            removed = true;\n            return listener !== serviceListener;\n        });\n        return removed;\n    }\n\n    /**\n     * Sends this event to all listeners belonging to a specific service type\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {Boolean} isEncrypted\n     */\n    sendEventServiceStarted (session, serviceType, isEncrypted) {\n        const listenerArray = this._listeners[serviceType];\n        for (const index in listenerArray) {\n            listenerArray[index].onServiceStarted(session, serviceType, isEncrypted);\n        }\n    }\n\n    /**\n     * Sends this event to all listeners belonging to a specific service type\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     */\n    sendEventServiceEnded (session, serviceType) {\n        const listenerArray = this._listeners[serviceType];\n        for (const index in listenerArray) {\n            listenerArray[index].onServiceEnded(session, serviceType);\n        }\n    }\n\n    /**\n     * Sends this event to all listeners belonging to a specific service type\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {String} reason\n     */\n    sendEventServiceError (session, serviceType, reason) {\n        const listenerArray = this._listeners[serviceType];\n        for (const index in listenerArray) {\n            listenerArray[index].onServiceError(session, serviceType, reason);\n        }\n    }\n}\n\nexport { ServiceListenerMap };\n","import { VideoStreamingFormat } from '../../rpc/structs/VideoStreamingFormat';\nimport { VideoStreamingCodec } from '../../rpc/enums/VideoStreamingCodec';\nimport { VideoStreamingProtocol } from '../../rpc/enums/VideoStreamingProtocol';\nimport { ImageResolution } from '../../rpc/structs/ImageResolution';\n\n/*\n * Copyright (c) 2019 Livio, Inc.\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided with the\n * distribution.\n *\n * Neither the name of the Livio Inc. nor the names of its contributors\n * may be used to endorse or promote products derived from this software\n * without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\nconst DEFAULT_PROTOCOL = VideoStreamingProtocol.RAW;\nconst DEFAULT_CODEC = VideoStreamingCodec.H264;\nconst DEFAULT_WIDTH = 1024;\nconst DEFAULT_HEIGHT = 576;\nconst DEFAULT_DENSITY = 240;\nconst DEFAULT_FRAMERATE = 30;\nconst DEFAULT_BITRATE = 512000;\nconst DEFAULT_INTERVAL = 5;\nconst DEFAULT_SCALE = 1.0;\n\nclass VideoStreamingParameters {\n    /**\n     *\n     * @param {number} displayDensity\n     * @param {number} frameRate\n     * @param {number} bitrate\n     * @param {number} interval\n     * @param {ImageResolution} resolution\n     * @param {VideoStreamingFormat} format\n     */\n    constructor (displayDensity = null, frameRate = null, bitrate = null, interval = null, resolution = null, format = null) {\n        this._displayDensity = displayDensity || DEFAULT_DENSITY;\n        this._frameRate = frameRate || DEFAULT_FRAMERATE;\n        this._bitrate = bitrate || DEFAULT_BITRATE;\n        this._interval = interval || DEFAULT_INTERVAL;\n\n        if (!(resolution instanceof ImageResolution)) {\n            resolution = new ImageResolution();\n            resolution.setResolutionWidth(DEFAULT_WIDTH);\n            resolution.setResolutionHeight(DEFAULT_HEIGHT);\n        }\n        this._resolution = resolution;\n\n        if (!(format instanceof VideoStreamingFormat)) {\n            format = new VideoStreamingFormat();\n            format.setProtocol(DEFAULT_PROTOCOL);\n            format.setCodec(DEFAULT_CODEC);\n        }\n\n        this._format = format;\n    }\n\n    /**\n     * Update the values contained in the capability that should have been returned through the SystemCapabilityManager.\n     * This update will use the most preferred streaming format from the module.\n     * @param {VideoStreamingCapability} capability the video streaming capability returned from the SystemCapabilityManager\n     */\n    update (capability) {\n        if (capability.getMaxBitrate() !== null) {\n            this._bitrate = capability.getMaxBitrate() * 1000; // NOTE: the unit of maxBitrate in getSystemCapability is kbps.\n        }\n        let scale = DEFAULT_SCALE;\n        if (capability.getScale() !== null) {\n            scale = capability.getScale();\n        }\n        const resolution = capability.getPreferredResolution();\n        if (resolution !== null) {\n            if (resolution.getResolutionHeight() !== null && resolution.getResolutionHeight() > 0) {\n                this._resolution.setResolutionHeight(Math.floor((resolution.getResolutionHeight() / scale)));\n            }\n            if (resolution.getResolutionWidth() !== null && resolution.getResolutionWidth() > 0) {\n                this._resolution.setResolutionWidth(Math.floor((resolution.getResolutionWidth() / scale)));\n            }\n        }\n        const formats = capability.getSupportedFormats();\n        if (formats !== null && formats.length > 0) {\n            this._format = formats[0];\n        }\n    }\n\n    /**\n     *\n     * @param {number} displayDensity\n     * @return {VideoStreamingParameters}\n     */\n    setDisplayDensity (displayDensity) {\n        this._displayDensity = displayDensity;\n        return this;\n    }\n\n    /**\n     * @return {number}\n     */\n    getDisplayDensity () {\n        return this._displayDensity;\n    }\n\n    /**\n     * @param {number} frameRate\n     * @return {VideoStreamingParameters}\n     */\n    setFrameRate (frameRate) {\n        this._frameRate = frameRate;\n    }\n\n    /**\n     * @return {number}\n     */\n    getFrameRate () {\n        return this._frameRate;\n    }\n\n    /**\n     * @param {number} bitrate\n     * @return {VideoStreamingParameters}\n     */\n    setBitrate (bitrate) {\n        this._bitrate = bitrate;\n        return this;\n    }\n    /**\n     * @return {number}\n     */\n    getBitrate () {\n        return this._bitrate;\n    }\n\n    /**\n     * @param {number} interval\n     * @return {VideoStreamingParameters}\n     */\n    setInterval (interval) {\n        this._interval = interval;\n        return this;\n    }\n\n    /**\n     * @return {number}\n     */\n    getInterval () {\n        return this._interval;\n    }\n\n    /**\n     * @param {VideoStreamingFormat} format\n     * @return {VideoStreamingParameters}\n     */\n    setFormat (format) {\n        this._format = format;\n        return this;\n    }\n\n    /**\n     * @return {VideoStreamingFormat}\n     */\n    getFormat () {\n        return this._format;\n    }\n\n    /**\n     * @param {number} resolution\n     * @return {VideoStreamingParameters}\n     */\n    setResolution (resolution) {\n        this._resolution = resolution;\n        return this;\n    }\n\n    /**\n     * @return {number}\n     */\n    getResolution () {\n        return this._resolution;\n    }\n}\n\nexport { VideoStreamingParameters };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SdlProtocolListener } from '../protocol/SdlProtocolListener.js';\nimport { SdlProtocol } from '../protocol/SdlProtocol.js';\nimport { ServiceType } from '../protocol/enums/ServiceType.js';\nimport { ServiceListenerMap } from './ServiceListenerMap.js';\nimport { VideoStreamingParameters } from '../streaming/video/VideoStreamingParameters.js';\n\n\n/**\n * @typedef {Object} SdlSession\n * @property {Function} start\n * @property {Function} getSessionId\n * @property {Function} onProtocolSessionStarted\n * @property {Function} onProtocolSessionEnded\n * @property {Function} onProtocolSessionEndedNACKed\n * @property {Function} onRpcMessageReceived\n * @property {Function} sendRpc\n * @property {Function} getMtu\n * @property {Function} close\n * @property {Function} startService\n * @property {Function} endService\n * @property {Function} getCurrentTransportType\n * @property {Function} getIsConnected\n * @property {Function} getProtocolVersion\n * @property {Function} getTransportConfig\n * @property {Function} getSessionHashId\n * @property {Function} addServiceListener\n * @property {Function} removeServiceListener\n * @property {Function} getServiceListeners\n */\nclass SdlSession {\n    /**\n     * @param {TransportConfigBase} baseTransportConfig\n     * @param {SdlSessionListener} sdlSessionListener\n     */\n    constructor (baseTransportConfig, sdlSessionListener) {\n        this._baseTransportConfig = baseTransportConfig;\n        this._sessionId = null;\n        this._sessionHashId = null;\n        this._sdlSessionListener = sdlSessionListener;\n        this._baseTransportConfig = baseTransportConfig;\n\n        // a hash where each key is a service type, and has an array of listeners attached\n        this._serviceListeners = new ServiceListenerMap();\n\n        this._sdlProtocolListener = this._setupSdlProtocolListener();\n\n        this._sdlProtocol = new SdlProtocol(baseTransportConfig, this._sdlProtocolListener);\n    }\n\n    /**\n     * @return {SdlProtocolListener}\n     * @private\n     */\n    _setupSdlProtocolListener () {\n        const sdlProtocolListener = new SdlProtocolListener();\n        sdlProtocolListener.setGetSessionId(this.getSessionId.bind(this));\n        sdlProtocolListener.setOnProtocolSessionStarted(this.onProtocolSessionStarted.bind(this));\n        sdlProtocolListener.setOnProtocolSessionEnded(this.onProtocolSessionEnded.bind(this));\n        sdlProtocolListener.setOnProtocolSessionEndedNACKed(this.onProtocolSessionEndedNACKed.bind(this));\n        sdlProtocolListener.setOnRpcMessageReceived(this.onRpcMessageReceived.bind(this));\n        sdlProtocolListener.setOnTransportConnected(this.onTransportConnected.bind(this));\n\n        sdlProtocolListener.setGetDesiredVideoParams(this.getDesiredVideoParams.bind(this));\n        sdlProtocolListener.setSetAcceptedVideoParams(this.setAcceptedVideoParams.bind(this));\n\n        return sdlProtocolListener;\n    }\n\n    /**\n     * Starts up the SDL protocol class. It will kick off the transport manager and underlying transport.\n     */\n    start () {\n        this._sdlProtocol.start();\n    }\n\n    /** **********************************************************************************************************************************************************************\n     *                                                       BEGIN:    SdlProtocolListener implemented methods\n     ************************************************************************************************************************************************************************/\n\n    /**\n     * @return {Number}  - represents a byte\n     */\n    getSessionId () {\n        return this._sessionId;\n    }\n\n    /**\n     * Event fired when transport (eg tcp, ws, bluetooth) has connected.\n     */\n    onTransportConnected () {\n        this._sdlSessionListener.onTransportConnected();\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {Number} version - represents a byte\n     * @param {String} correlationId\n     * @param {Number} hashId\n     * @param {Boolean} isEncrypted\n     */\n    onProtocolSessionStarted (serviceType, sessionId, version, correlationId, hashId, isEncrypted) {\n        this._sessionId = sessionId;\n\n        if (serviceType === ServiceType.RPC) {\n            this._sessionHashId = hashId;\n        }\n\n        this._sdlSessionListener.onProtocolSessionStarted(serviceType, sessionId, version, correlationId, hashId, isEncrypted);\n        this._serviceListeners.sendEventServiceStarted(this, serviceType, isEncrypted);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {String} correlationId\n     */\n    onProtocolSessionEnded (serviceType, sessionId, correlationId) {\n        this._sdlSessionListener.onProtocolSessionEnded(serviceType, sessionId, correlationId);\n        this._serviceListeners.sendEventServiceEnded(this, serviceType);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {String} correlationId\n     */\n    onProtocolSessionEndedNACKed (serviceType, sessionId, correlationId) {\n        this._sdlSessionListener.onProtocolSessionEndedNACKed(serviceType, sessionId, correlationId);\n        this._serviceListeners.sendEventServiceError(this, serviceType, `End ${serviceType.toString()} Service NACK'ed`);\n    }\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessageReceived (rpcMessage) {\n        this._sdlSessionListener.onRpcMessageReceived(rpcMessage);\n    }\n\n\n    /** **********************************************************************************************************************************************************************\n     *                                                       END:    SdlProtocolListener implemented methods\n     ************************************************************************************************************************************************************************/\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    sendRpc (rpcMessage) {\n        this._sdlProtocol.sendRpc(rpcMessage);\n    }\n\n    /**\n     * Sends an sdlPacket.\n     * @param {SdlPacket} sdlPacket\n     */\n    sendPacket (sdlPacket) {\n        this._sdlProtocol.sendPacket(sdlPacket);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @return {Number} max transport unit for the given service type\n     */\n    getMtu (serviceType) {\n        this._sdlProtocol.getMtu(serviceType);\n    }\n\n    /**\n     * Ends the current session\n     */\n    close () {\n        this._sdlProtocol.endSession(this._sessionId, this._sessionHashId);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {Boolean} isEncrypted\n     */\n    startService (serviceType, sessionId, isEncrypted) {\n        this._sdlProtocol.startService(serviceType, sessionId, isEncrypted);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     */\n    endService (serviceType, sessionId) {\n        this._sdlProtocol.endService(serviceType, sessionId);\n    }\n\n    /**\n     * @return {TransportType}\n     */\n    getCurrentTransportType () {\n        return this._baseTransportConfig.getTransportType();\n    }\n\n    /**\n     * @return {Boolean} isConnected\n     */\n    getIsConnected () {\n        return this._sdlProtocol.isConnected();\n    }\n\n    /**\n     * @return {Version}\n     */\n    getProtocolVersion () {\n        return this._sdlProtocol.getProtocolVersion();\n    }\n\n    /**\n     * @return {TransportConfigBase}\n     */\n    getTransportConfig () {\n        return this._baseTransportConfig;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSessionHashId () {\n        return this._sessionHashId;\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} sdlServiceListener\n     */\n    addServiceListener (serviceType, sdlServiceListener) {\n        this._serviceListeners.addListener(serviceType, sdlServiceListener);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} sdlServiceListener\n     * @return {Boolean} - whether the removal was successful\n     */\n    removeServiceListener (serviceType, sdlServiceListener) {\n        return this._serviceListeners.removeListener(serviceType, sdlServiceListener);\n    }\n\n    /**\n     * @return {ServiceListenerMap}\n     */\n    getServiceListeners () {\n        return this._serviceListeners;\n    }\n\n    /**\n     *\n     * @param {VideoStreamingParameters} params\n     */\n    setDesiredVideoParams (params) {\n        this._desiredVideoParams = params;\n        return this;\n    }\n\n    /**\n     * Returns the currently set desired video streaming parameters. If there haven't been any set,\n     * the default options will be returned and set for this instance.\n     * @return {VideoStreamingParameters} the desired video streaming parameters\n     */\n    getDesiredVideoParams () {\n        if (!(this._desiredVideoParams instanceof VideoStreamingParameters)) {\n            this._desiredVideoParams = new VideoStreamingParameters();\n        }\n        return this._desiredVideoParams;\n    }\n\n    /**\n     * @param {VideoStreamingParameters} params\n     */\n    setAcceptedVideoParams (params) {\n        this._desiredVideoParams = params;\n        return this;\n    }\n}\n\nexport { SdlSession };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} SdlSessionListener\n */\nclass SdlSessionListener {\n    /**\n\t * @constructor\n\t */\n    constructor () {\n        this._onProtocolSessionStarted = null;\n        this._onProtocolSessionEnded = null;\n        this._onProtocolSessionEndedNACKed = null;\n        this._onRpcMessageReceived = null;\n        this._onTransportConnected = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionStarted (listener) {\n        this._onProtocolSessionStarted = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEnded (listener) {\n        this._onProtocolSessionEnded = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEndedNACKed (listener) {\n        this._onProtocolSessionEndedNACKed = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnRpcMessageReceived (listener) {\n        this._onRpcMessageReceived = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnTransportConnected (listener) {\n        this._onTransportConnected = listener;\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID - represents a byte\n     * @param {Number} version - represents a byte\n     * @param {String} correlationID\n     * @param {Number} hashID\n     * @param {Boolean} isEncrypted\n     */\n    onProtocolSessionStarted (serviceType, sessionID, version, correlationID, hashID, isEncrypted) {\n        if (typeof this._onProtocolSessionStarted === 'function') {\n            this._onProtocolSessionStarted(serviceType, sessionID, version, correlationID, hashID, isEncrypted);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID - represents a byte\n     * @param {String} correlationID\n     */\n    onProtocolSessionEnded (serviceType, sessionID, correlationID) {\n        if (typeof this._onProtocolSessionEnded === 'function') {\n            this._onProtocolSessionEnded(serviceType, sessionID, correlationID);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID - represents a byte\n     * @param {String} correlationID\n     */\n    onProtocolSessionEndedNACKed (serviceType, sessionID, correlationI) {\n        if (typeof this._onProtocolSessionEndedNACKed === 'function') {\n            this._onProtocolSessionEndedNACKed(serviceType, sessionID, correlationI);\n        }\n    }\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessageReceived (rpcMessage) {\n        if (typeof this._onRpcMessageReceived === 'function') {\n            this._onRpcMessageReceived(rpcMessage);\n        }\n    }\n\n    /**\n     * Invoked when the app and core connect\n     */\n    onTransportConnected () {\n        if (typeof this._onTransportConnected === 'function') {\n            this._onTransportConnected();\n        }\n    }\n}\n\nexport { SdlSessionListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} ArrayTools\n */\nclass ArrayTools {\n    /**\n     * Removes the item from the array.\n     * This does not mutate the passed in array.\n     * Only the returned array has the value removed.\n     * @param {Array} array\n     * @param {any} value\n     * @return {Array}\n     */\n    static arrayRemove (array, value) {\n        return array.filter(function (ele) {\n            return ele !== value;\n        });\n    }\n}\nexport { ArrayTools };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RegisterAppInterface } from '../../rpc/messages/RegisterAppInterface.js';\nimport { RpcRequest } from '../../rpc/RpcRequest.js';\nimport { RpcResponse } from '../../rpc/RpcResponse.js';\nimport { RpcListener } from '../../rpc/RpcListener.js';\nimport { SdlSession } from '../../session/SdlSession.js';\nimport { SdlSessionListener } from '../../session/SdlSessionListener.js';\nimport { Version } from '../../util/Version.js';\nimport { ArrayTools } from '../../util/ArrayTools.js';\nimport { SdlMsgVersion } from '../../rpc/structs/SdlMsgVersion.js';\nimport { FunctionID } from '../../rpc/enums/FunctionID.js';\nimport { ServiceType } from '../../protocol/enums/ServiceType.js';\n\n/**\n * NOTE: This could all change and should only be used for testing.\n * This class should also be marked private and behind the SdlManager API\n *\n * usage should be:\n * var lcm = new LifecycleManager(appConfig, lifecycleListener);\n * lcm.setRpcListener( ... );\n * lcm.start();\n * ....\n *\n * lifecycleListener.OnProxyConnected(){\n *  //Possible to start sending RPCs, HMI level should be NONE to start\n *\n * }\n *\n */\nclass LifecycleManager {\n    /**\n    * @param {AppConfig} sdlConfig\n    * @param {LifecycleListener} lifecycleListener\n    * @constructor\n    */\n    constructor (appConfig, lifecycleListener) {\n        if (appConfig === null || lifecycleListener === null\n            || appConfig === undefined || lifecycleListener === undefined\n        ) {\n            throw new Error('Params must not be null');\n        }\n\n        this._appConfig = appConfig;\n        this._lifecycleListener = lifecycleListener;\n        this._sdlSession = new SdlSession(this._appConfig.getTransportConfig(), this._createSessionListener());\n\n        // This is by default until we receive the RAI Response\n        this._rpcSpecVersion = new Version(1, 0, 0);\n\n        this._currentHMIStatus = null;\n        this._firstTimeFull = true;\n        this._responseListeners = new Map();\n        this._maxCorrelationId = 0; // TODO remove when correlation gen is implemented\n        this._rpcListeners = new Map(); // <Number, Array<RpcListener>>\n    }\n\n    /**\n     * @return {SdlSessionListener}\n     */\n    _createSessionListener () {\n        const sessionListener = new SdlSessionListener();\n        sessionListener.setOnProtocolSessionStarted((serviceType, sessionID, version, correlationID, hashID, isEncrypted) => {\n            // Session has been started\n            // TODO check min protocol spec version\n            if (serviceType === ServiceType.RPC) {\n                if (this._appConfig !== null && this._appConfig !== undefined) {\n                    // TODO call prepare on config to make sure it is satisfactory\n                    this.sendRpcMessage(this._createRegisterAppInterface());\n                }\n            }\n        });\n        sessionListener.setOnProtocolSessionEnded((serviceType, sessionID, correlationID) => {\n            // Session has been ended\n        });\n        sessionListener.setOnProtocolSessionEndedNACKed((serviceType, sessionID, correlationID) => {\n            // TODO im not sure why we have this\n        });\n        sessionListener.setOnRpcMessageReceived((rpcMessage) => {\n            // Message has been received\n            this._handleRpc(rpcMessage);\n        });\n        sessionListener.setOnTransportConnected(() => {\n            // transport has been connected\n            this._sdlSession.startService(ServiceType.RPC, 0, false);\n        });\n\n        return sessionListener;\n    }\n\n    /**\n     * @param { RpcMessage } rpcMessage\n     */\n    _handleRpc (rpcMessage) {\n        if (rpcMessage === null || rpcMessage === undefined || rpcMessage.getFunctionName() === null || rpcMessage.getFunctionName() === undefined) {\n            return;\n        }\n\n        const functionID = FunctionID.valueForKey(rpcMessage.getFunctionName()); // this is the number value\n        const listenerArray = this._rpcListeners.get(functionID);\n        if (listenerArray !== null && listenerArray !== undefined) {\n            listenerArray.forEach(function (item) {\n                item.onRpcMessage(rpcMessage);\n            });\n        }\n\n        // Handle individual RPC listeners for request/response pairs\n        if (rpcMessage instanceof RpcResponse) {\n            // null check not needed. its always defined in the constructor\n            if (this._responseListeners.has(rpcMessage.getCorrelationId())) {\n                this._responseListeners.get(rpcMessage.getCorrelationId()).resolve();\n            }\n        }\n    }\n\n    /**\n    * @return {LifecycleManager}\n    */\n    start () {\n        this._setupInternalRpcListeners();\n        this._sdlSession.start();\n        return this;\n    }\n\n    stop () {\n        this._sdlSession.close();\n    }\n\n\n    /**\n     *\n     * @param {FunctionID} functionID\n     * @param {RpcListener} rpcListener\n     */\n    addRpcListener (functionID, rpcListener) {\n        let listenerArray = this._rpcListeners.get(functionID);\n        // If no array exists yet for this function id, create one\n        if (listenerArray === null || listenerArray === undefined) {\n            this._rpcListeners.set(functionID, []);\n            listenerArray = this._rpcListeners.get(functionID);\n        }\n        listenerArray.push(rpcListener);\n    }\n\n    /**\n     *\n     * @param {FunctionID} functionID\n     * @param {RpcListener} rpcListener\n     */\n    removeRpcListener (functionID, rpcListener) {\n        if (rpcListener !== null && rpcListener !== undefined) {\n            const listenerArray = this._rpcListeners.get(functionID);\n            if (listenerArray !== null && listenerArray !== undefined) {\n                this._rpcListeners.set(functionID, ArrayTools.arrayRemove(listenerArray, rpcListener));\n            }\n        }\n    }\n\n    /**\n     *\n     * @param {RpcMessage} rpcMessage\n     */\n    sendRpcMessage (rpcMessage) {\n        if (rpcMessage !== null && rpcMessage !== undefined && this._sdlSession.getIsConnected()) {\n            // TODO we still need to make proper changes to handle specific cases for RPCs ie PLAY_PAUSE / OK\n\n            // TODO create a correlation id generator and handle this in the RPC classes\n            if (rpcMessage instanceof RpcRequest) {\n                if (rpcMessage.getFunctionName !== FunctionID.RegisterAppInterface) { // RAI has a a protected id\n                    rpcMessage.setCorrelationId(++this._maxCorrelationId);\n                }\n\n                // TODO: can't utilize the ability of promises like this\n                if (rpcMessage.getOnRPCResponsePromise() !== null && rpcMessage.getOnRPCResponsePromise() !== undefined) {\n                    // Set the individual response listener for this RPC message\n                    this._responseListeners.set(rpcMessage.getCorrelationId(), rpcMessage.getOnRPCResponsePromise());\n                }\n            }\n            this._sdlSession.sendRpc(rpcMessage);\n        }\n    }\n\n\n\n    /**\n     * @return {RegisterAppInterfaceResponse}\n     */\n    getRegisterAppInterfaceResponse () {\n        return this._registerAppInterfaceResponse;\n    }\n\n\n\n    /**\n    * @return {RegisterAppInterface}\n    */\n    _createRegisterAppInterface () {\n        const registerAppInterface = new RegisterAppInterface();\n        registerAppInterface.setSdlMsgVersion(new SdlMsgVersion().setMajorVersion(LifecycleManager.MAX_RPC_VERSION.getMajor()).setMinorVersion(LifecycleManager.MAX_RPC_VERSION.getMinor()).setPatchVersion(LifecycleManager.MAX_RPC_VERSION.getPatch()))\n            .setAppName(this._appConfig.getAppName())\n            .setFullAppId(this._appConfig.getAppId())\n            .setNgnMediaScreenAppName(this._appConfig.getShortAppName())\n            .setAppHmiType(this._appConfig.getAppTypes())\n            .setLanguageDesired(this._appConfig.getLanguageDesired())\n            .setHmiDisplayLanguageDesired(this._appConfig.getHmiDisplayLanguageDesired())\n            .setIsMediaApplication(this._appConfig.isMediaApp())\n            .setDayColorScheme(this._appConfig.getDayColorScheme())\n            .setNightColorScheme(this._appConfig.getNightColorScheme())\n            .setCorrelationId(LifecycleManager.REGISTER_APP_INTERFACE_CORRELATION_ID);\n\n        // TODO Add all possible items\n\n        return registerAppInterface;\n    }\n\n\n    /* *******************************************************************************************************\n     ********************************** INTERNAL - RPC LISTENERS !! START !! *********************************\n     *********************************************************************************************************/\n\n    _setupInternalRpcListeners () {\n        this._rpcListener = new RpcListener().setOnRpcMessage(rpcMessage => {\n            const functionID = FunctionID.valueForKey(rpcMessage.getFunctionName()); // this is the number value\n\n\n            switch (functionID) {\n                case FunctionID.RegisterAppInterface:\n                    this._processRaiResponse(rpcMessage);\n                    break;\n                case FunctionID.OnHMIStatus: {\n                    // send a single onProxyConnected, when we go from a null HMI level to a defined HMI level\n                    const shouldInit = rpcMessage.getHMILevel() !== null\n                        && rpcMessage.getHMILevel() !== undefined\n                        && this._currentHMIStatus === null;\n\n                    this._currentHMIStatus = rpcMessage.getHMILevel();\n\n                    if (this._lifecycleListener !== null && this._lifecycleListener !== undefined && shouldInit) {\n                        this._lifecycleListener.onProxyConnected(this);\n                    }\n                    break;\n                }\n                default:\n                // RPC not handled yet in LCM\n            }\n        });\n\n        this.addRpcListener(FunctionID.RegisterAppInterface, this._rpcListener);\n        this.addRpcListener(FunctionID.OnHMIStatus, this._rpcListener);\n    }\n\n    /**\n     *\n     * @param {RegisterAppInterfaceResponse} registerAppInterfaceResponse\n     */\n    _processRaiResponse (registerAppInterfaceResponse) {\n        // Cache this RAI Response as it can be used later\n        this._registerAppInterfaceResponse = registerAppInterfaceResponse;\n\n        //  TODO KEY_SDL_MSG_VERSION vs KEY_SYNC_MSG_VERSION sdlVersion: '{GIT_COMMIT}', I think the key name change\n        // is meant to make things clearer about this being an sdl version which is not specific to ford's sync.\n        // There is a key called sdlVersion that is responding with {GIT_COMMIT} that I'm unsure what it is supposed to do.\n        const msgVersion = registerAppInterfaceResponse.getSdlMsgVersion();\n\n        if (msgVersion !== null && msgVersion !== undefined) {\n            this._rpcSpecVersion = new Version(msgVersion.getMajorVersion(), msgVersion.getMajorVersion(), msgVersion.getPatchVersion());\n        } else {\n            this._rpcSpecVersion = LifecycleManager.MAX_RPC_VERSION;\n        }\n\n\n        // TODO check against min RPC spec version config\n\n        // TODO parse RAI for system capabilities\n    }\n}\n\nLifecycleManager.MAX_RPC_VERSION = new Version(6, 0, 0);\nLifecycleManager.REGISTER_APP_INTERFACE_CORRELATION_ID = 65529;\nLifecycleManager.UNREGISTER_APP_INTERFACE_CORRELATION_ID = 65530;\n\n\nexport { LifecycleManager };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VideoStreamingFormat } from './VideoStreamingFormat.js';\nimport { ImageResolution } from './ImageResolution.js';\n\nclass VideoStreamingCapability extends RpcStruct {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @param {ImageResolution} val\n    * @return {VideoStreamingCapability}\n    */\n    setPreferredResolution (val) {\n        this.validateType(ImageResolution, val);\n        this.setParameter(VideoStreamingCapability.KEY_PREFERRED_RESOLUTION, val);\n        return this;\n    }\n\n    /**\n    * @return {ImageResolution}\n    */\n    getPreferredResolution () {\n        return this.getObject(ImageResolution, VideoStreamingCapability.KEY_PREFERRED_RESOLUTION);\n    }\n\n    /**\n    * @param {number} val\n    * @return {VideoStreamingCapability}\n    */\n    setMaxBitrate (val) {\n        this.setParameter(VideoStreamingCapability.KEY_MAX_BITRATE, val);\n        return this;\n    }\n\n    /**\n    * @return {number}\n    */\n    getMaxBitrate () {\n        return this.getParameter(VideoStreamingCapability.KEY_MAX_BITRATE);\n    }\n\n\n    /**\n    * @param {VideoStreamingFormat[]} val\n    * @return {VideoStreamingCapability}\n    */\n    setSupportedFormats (val) {\n        this.validateType(VideoStreamingFormat, val, true);\n        this.setParameter(VideoStreamingCapability.KEY_SUPPORTED_FORMATS, val);\n    }\n\n    /**\n    * @return {VideoStreamingFormat[]}\n    */\n    getSupportedFormats () {\n        return this.getObject(VideoStreamingFormat, VideoStreamingCapability.KEY_SUPPORTED_FORMATS);\n    }\n\n    /**\n    * @param {Boolean} val\n    * @return {VideoStreamingCapability}\n    */\n    setHapticSpatialDataSupported (val) {\n        this.setParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED, val);\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getHapticSpatialDataSupported () {\n        return this.getParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED);\n    }\n\n    /**\n    * @param {number} val\n    * @return {VideoStreamingCapability}\n    */\n    setDiagonalScreenSize (val) {\n        this.setParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE, val);\n        return this;\n    }\n\n    /**\n    * @return {number}\n    */\n    getDiagonalScreenSize () {\n        return this.getParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE);\n    }\n\n    /**\n    * @param {number} val\n    * @return {VideoStreamingCapability}\n    */\n    setPixelPerInch (val) {\n        this.setParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH, val);\n        return this;\n    }\n\n    /**\n    * @return {number}\n    */\n    getPixelPerInch () {\n        return this.getParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH);\n    }\n\n    /**\n    * @param {number} val\n    * @return {VideoStreamingCapability}\n    */\n    setScale (val) {\n        this.setParameter(VideoStreamingCapability.KEY_SCALE, val);\n        return this;\n    }\n\n    /**\n    * @return {number}\n    */\n    getScale () {\n        return this.getParameter(VideoStreamingCapability.KEY_SCALE);\n    }\n}\n\nVideoStreamingCapability.KEY_PREFERRED_RESOLUTION = 'preferredResolution';\nVideoStreamingCapability.KEY_MAX_BITRATE = 'maxBitrate';\nVideoStreamingCapability.KEY_SUPPORTED_FORMATS = 'supportedFormats';\nVideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED = 'hapticSpatialDataSupported';\nVideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE = 'diagonalScreenSize';\nVideoStreamingCapability.KEY_PIXEL_PER_INCH = 'pixelPerInch';\nVideoStreamingCapability.KEY_SCALE = 'scale';\n\nexport { VideoStreamingCapability };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} SdlServiceListener\n */\nclass SdlServiceListener {\n    /**\n\t * @constructor\n\t */\n    constructor () {\n        this._onServiceStarted = null;\n        this._onServiceEnded = null;\n        this._onServiceError = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceStarted (listener) {\n        this._onServiceStarted = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceEnded (listener) {\n        this._onServiceEnded = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceError (listener) {\n        this._onServiceError = listener;\n    }\n\n    /**\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {Boolean} isEncrypted\n     */\n    onServiceStarted (session, serviceType, isEncrypted) {\n        if (typeof this._onServiceStarted === 'function') {\n            this._onServiceStarted(session, serviceType, isEncrypted);\n        }\n    }\n\n    /**\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     */\n    onServiceEnded (session, serviceType) {\n        if (typeof this._onServiceEnded === 'function') {\n            this._onServiceEnded(session, serviceType);\n        }\n    }\n\n    /**\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {String} reason\n     */\n    onServiceError (session, serviceType, reason) {\n        if (typeof this._onServiceError === 'function') {\n            this._onServiceError(session, serviceType, reason);\n        }\n    }\n}\n\nexport { SdlServiceListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportBase } from './TransportBase.js';\nimport { SdlPsm } from './SdlPsm.js';\n\nclass CustomTransport extends TransportBase {\n    constructor (transportConfig, transportCallback = null) {\n        super(transportConfig, transportCallback);\n        this._queue = [];\n        this._isRunning = false;\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        this._transportCallback = callback;\n        return this;\n    }\n\n    /**\n     * Triggers the transport callback for connection established\n     */\n    start () {\n        if (this._transportCallback !== null) {\n            this._transportCallback.onConnectionEstablished();\n        }\n    }\n\n    /**\n     * Triggers the transport callback for connection terminated\n     */\n    stop () {\n        if (this._transportCallback !== null) {\n            this._transportCallback.onConnectionTerminated('Transport told to stop');\n        }\n    }\n\n    /**\n     * Triggers the transport callback for an error\n     */\n    onError () {\n        if (this._transportCallback !== null) {\n            this._transportCallback.onError();\n        }\n    }\n\n    /**\n     * The contents in the packet should be sent out through the transport\n     * @param {SdlPacket} packet\n     */\n    sendPacket (packet) {\n        const bytes = packet.toPacket();\n        this.onSendPacket(bytes, 0, bytes.length);\n    }\n\n    /**\n     * The app instantiating this class needs to implement this method! sendPacket calls this method\n     * @param {UInt8Array} bytes\n     */\n    onSendPacket (bytes) {\n        throw new Error('onSendPacket method must be overridden');\n    }\n\n    /**\n     * A byte buffer was passed here for processing\n     * @param {Uint8Array} message\n     */\n    onByteBufferReceived (message) {\n        this._queue.push(message);\n        this._multiByteHandler();\n    }\n\n    /**\n     * Processes received data from the internal queue\n     * @private\n     */\n    _multiByteHandler () {\n        if (this._isRunning) {\n            return;\n        }\n        this._isRunning = true;\n\n        while (this._queue.length > 0) {\n            const uint8 = this._queue.shift();\n            for (const byte of uint8) {\n                this._handleByte(byte);\n            }\n        }\n\n        this._isRunning = false;\n    }\n\n    /**\n     * Feeds a byte through the internal PSM\n     * @param {Number} byte - unsigned 8-bit integer\n     * @private\n     */\n    _handleByte (byte) {\n        const sdlPsm = this._sdlPsm;\n\n        const success = sdlPsm.handleByte(byte);\n        if (!success) {\n            console.error('failed', sdlPsm);\n            sdlPsm.reset();\n        }\n        const isFinished = sdlPsm.getState() === SdlPsm.FINISHED_STATE;\n\n        if (isFinished) {\n            const packet = sdlPsm.getFormedPacket();\n            sdlPsm.reset();\n            if (this._transportCallback !== null) {\n                this._transportCallback.onPacketReceived(packet);\n            }\n        }\n    }\n}\n\n\nexport { CustomTransport };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} TransportConfigBase\n * @property {TransportType} _transportType\n * @property {Function} getTransportType\n */\nclass TransportConfigBase {\n    /**\n     * @constructor\n     * @param {TransportType} transportType - enum\n     */\n    constructor (transportType) {\n        this._transportType = transportType;\n    }\n\n    /**\n     * @return {TransportType}\n     */\n    getTransportType () {\n        return this._transportType;\n    }\n}\n\nexport { TransportConfigBase };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportConfigBase } from './TransportConfigBase.js';\nimport { TransportType } from './enums/TransportType.js';\n\nclass CustomTransportConfig extends TransportConfigBase {\n    /**\n    * @constructor\n    * @param {CustomTransport} customTransport - An instance of a custom transport\n    */\n    constructor (customTransport) {\n        super(TransportType.CUSTOM);\n        this._customTransport = customTransport;\n    }\n\n    getTransportType () {\n        return TransportType.CUSTOM;\n    }\n\n    getTransport () {\n        return this._customTransport;\n    }\n}\n\nexport { CustomTransportConfig };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass SslConfig {\n    constructor (pemCertificate = null, privateKey = null, password = null) {\n        this._pemCertificate = pemCertificate;\n        this._privateKey = privateKey;\n        this._password = password;\n    }\n\n    /**\n    * Returns the PEM Certificate\n    * @return {string}\n    */\n    getPemCertificate () {\n        return this._pemCertificate;\n    }\n\n    /**\n    * Returns the Private Key\n    * @return {string}\n    */\n    getPrivateKey () {\n        return this._privateKey;\n    }\n\n    /**\n    * Returns the password\n    * @return {string}\n    */\n    getPassword () {\n        return this._password;\n    }\n}\n\nexport { SslConfig };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportType } from './enums/TransportType.js';\nimport { TransportConfigBase } from './TransportConfigBase.js';\n\n\n/**\n * @typedef {Object} TransportConfigBase\n * @property {TransportType} _transportType\n * @property {Function} getTransportType\n */\nclass WebSocketClientConfig extends TransportConfigBase {\n    /**\n     * @constructor\n     * @param {TransportType} transportType - enum\n     */\n    constructor (host, port) {\n        super(TransportType.WEBSOCKET_CLIENT);\n\n        this._host = host;\n        this._port = port;\n    }\n\n    /**\n     * @return String\n     */\n    getHost () {\n        return this._host;\n    }\n\n    /**\n     * @return Number\n     */\n    getPort () {\n        return this._port;\n    }\n}\n\nexport { WebSocketClientConfig };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass TransportRecord {\n    /**\n    * @constructor\n    * @param {TransportType} transportType - The type of the transport\n    * @param {String} address\n    */\n    constructor (transportType, address) {\n        this._type = transportType;\n        this._address = address;\n    }\n\n    getType () {\n        return this._type;\n    }\n\n    getAddress () {\n        return this._address;\n    }\n\n    equals (obj) {\n        return (\n            obj instanceof TransportRecord\n            && obj.getType !== null\n            && obj.getType() === this.getType()\n            && obj.getAddress() === this.getAddress()\n        );\n    }\n\n    toString () {\n        return `Transport Type: ${this._type.name()} \\n Address: ${this._address}`;\n    }\n}\n\nexport { TransportRecord };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nconst { TransportConfigBase } = require('./TransportConfigBase.js');\nconst { TransportType } = require('./enums/TransportType.js');\n\nclass WebSocketServerConfig extends TransportConfigBase {\n    /**\n    * @constructor\n    * @param {WebSocket.client} client - A client connection reference made from a WebSocket server\n    */\n    constructor (client = null, connectionLostTimeout = 60000) {\n        super(TransportType.WEBSOCKET_SERVER);\n        this._client = client;\n        this._connectionLostTimeout = connectionLostTimeout;\n\n        if (client === null) {\n            throw Error('client must be a WebSocket client');\n        }\n    }\n\n    /**\n    * Returns the websocket client\n    * @return {WebSocket.client}\n    */\n    getClient () {\n        return this._client;\n    }\n\n    /**\n    * Returns the websocket connection lost timeout value in milliseconds\n    * @return {Number}\n    */\n    getConnectionLostTimeout () {\n        return this._connectionLostTimeout;\n    }\n}\n\nmodule.exports = {\n    WebSocketServerConfig,\n};","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { AppConfig } from './tmp/manager/AppConfig.js';\nimport { LifecycleListener } from './tmp/manager/lifecycle/LifecycleListener.js';\nimport { LifecycleManager } from './tmp/manager/lifecycle/LifecycleManager.js';\nimport { BinaryFrameHeader } from './tmp/protocol/BinaryFrameHeader.js';\nimport { MessageFrameAssembler } from './tmp/protocol/MessageFrameAssembler.js';\nimport { MessageFrameDisassembler } from './tmp/protocol/MessageFrameDisassembler.js';\nimport { SdlPacket } from './tmp/protocol/SdlPacket.js';\nimport { SdlPacketFactory } from './tmp/protocol/SdlPacketFactory.js';\nimport { SdlProtocol } from './tmp/protocol/SdlProtocol.js';\nimport { SdlProtocolBase } from './tmp/protocol/SdlProtocolBase.js';\nimport { SdlProtocolListener } from './tmp/protocol/SdlProtocolListener.js';\nimport { ControlFrameTags } from './tmp/protocol/enums/ControlFrameTags.js';\nimport { FrameType } from './tmp/protocol/enums/FrameType.js';\nimport { ServiceType } from './tmp/protocol/enums/ServiceType.js';\nimport { RpcCreator } from './tmp/rpc/RpcCreator.js';\nimport { RpcListener } from './tmp/rpc/RpcListener.js';\nimport { RpcMessage } from './tmp/rpc/RpcMessage.js';\nimport { RpcNotification } from './tmp/rpc/RpcNotification.js';\nimport { RpcRequest } from './tmp/rpc/RpcRequest.js';\nimport { RpcResponse } from './tmp/rpc/RpcResponse.js';\nimport { RpcStruct } from './tmp/rpc/RpcStruct.js';\nimport { AppHMIType } from './tmp/rpc/enums/AppHMIType.js';\nimport { AudioStreamingState } from './tmp/rpc/enums/AudioStreamingState.js';\nimport { AudioType } from './tmp/rpc/enums/AudioType.js';\nimport { BitsPerSample } from './tmp/rpc/enums/BitsPerSample.js';\nimport { ButtonName } from './tmp/rpc/enums/ButtonName.js';\nimport { CharacterSet } from './tmp/rpc/enums/CharacterSet.js';\nimport { DisplayType } from './tmp/rpc/enums/DisplayType.js';\nimport { FileType } from './tmp/rpc/enums/FileType.js';\nimport { FunctionID } from './tmp/rpc/enums/FunctionID.js';\nimport { HMILevel } from './tmp/rpc/enums/HMILevel.js';\nimport { HmiZoneCapabilities } from './tmp/rpc/enums/HmiZoneCapabilities.js';\nimport { ImageFieldName } from './tmp/rpc/enums/ImageFieldName.js';\nimport { ImageType } from './tmp/rpc/enums/ImageType.js';\nimport { Language } from './tmp/rpc/enums/Language.js';\nimport { MediaClockFormat } from './tmp/rpc/enums/MediaClockFormat.js';\nimport { MetadataType } from './tmp/rpc/enums/MetadataType.js';\nimport { PrerecordedSpeech } from './tmp/rpc/enums/PrerecordedSpeech.js';\nimport { Result } from './tmp/rpc/enums/Result.js';\nimport { RpcType } from './tmp/rpc/enums/RpcType.js';\nimport { SamplingRate } from './tmp/rpc/enums/SamplingRate.js';\nimport { SoftButtonType } from './tmp/rpc/enums/SoftButtonType.js';\nimport { SpeechCapabilities } from './tmp/rpc/enums/SpeechCapabilities.js';\nimport { SystemAction } from './tmp/rpc/enums/SystemAction.js';\nimport { SystemContext } from './tmp/rpc/enums/SystemContext.js';\nimport { TextAlignment } from './tmp/rpc/enums/TextAlignment.js';\nimport { TextFieldName } from './tmp/rpc/enums/TextFieldName.js';\nimport { VideoStreamingCodec } from './tmp/rpc/enums/VideoStreamingCodec.js';\nimport { VideoStreamingProtocol } from './tmp/rpc/enums/VideoStreamingProtocol.js';\nimport { VideoStreamingState } from './tmp/rpc/enums/VideoStreamingState.js';\nimport { VrCapabilities } from './tmp/rpc/enums/VrCapabilities.js';\nimport { AddCommand } from './tmp/rpc/messages/AddCommand.js';\nimport { AddCommandResponse } from './tmp/rpc/messages/AddCommandResponse.js';\nimport { OnHmiStatus } from './tmp/rpc/messages/OnHmiStatus.js';\nimport { OnLanguageChange } from './tmp/rpc/messages/OnLanguageChange.js';\nimport { PutFile } from './tmp/rpc/messages/PutFile.js';\nimport { PutFileResponse } from './tmp/rpc/messages/PutFileResponse.js';\nimport { RegisterAppInterface } from './tmp/rpc/messages/RegisterAppInterface.js';\nimport { RegisterAppInterfaceResponse } from './tmp/rpc/messages/RegisterAppInterfaceResponse.js';\nimport { SetAppIcon } from './tmp/rpc/messages/SetAppIcon.js';\nimport { SetAppIconResponse } from './tmp/rpc/messages/SetAppIconResponse.js';\nimport { Show } from './tmp/rpc/messages/Show.js';\nimport { ShowResponse } from './tmp/rpc/messages/ShowResponse.js';\nimport { UnregisterAppInterface } from './tmp/rpc/messages/UnregisterAppInterface.js';\nimport { UnregisterAppInterfaceResponse } from './tmp/rpc/messages/UnregisterAppInterfaceResponse.js';\nimport { AppInfo } from './tmp/rpc/structs/AppInfo.js';\nimport { AudioPassThruCapabilities } from './tmp/rpc/structs/AudioPassThruCapabilities.js';\nimport { ButtonCapabilities } from './tmp/rpc/structs/ButtonCapabilities.js';\nimport { DeviceInfo } from './tmp/rpc/structs/DeviceInfo.js';\nimport { DisplayCapabilities } from './tmp/rpc/structs/DisplayCapabilities.js';\nimport { Grid } from './tmp/rpc/structs/Grid.js';\nimport { HMICapabilities } from './tmp/rpc/structs/HMICapabilities.js';\nimport { Image } from './tmp/rpc/structs/Image.js';\nimport { ImageField } from './tmp/rpc/structs/ImageField.js';\nimport { ImageResolution } from './tmp/rpc/structs/ImageResolution.js';\nimport { MenuParams } from './tmp/rpc/structs/MenuParams.js';\nimport { MetadataTags } from './tmp/rpc/structs/MetadataTags.js';\nimport { ModuleInfo } from './tmp/rpc/structs/ModuleInfo.js';\nimport { PresetBankCapabilities } from './tmp/rpc/structs/PresetBankCapabilities.js';\nimport { RGBColor } from './tmp/rpc/structs/RGBColor.js';\nimport { ScreenParams } from './tmp/rpc/structs/ScreenParams.js';\nimport { SdlMsgVersion } from './tmp/rpc/structs/SdlMsgVersion.js';\nimport { SoftButton } from './tmp/rpc/structs/SoftButton.js';\nimport { SoftButtonCapabilities } from './tmp/rpc/structs/SoftButtonCapabilities.js';\nimport { TTSChunk } from './tmp/rpc/structs/TTSChunk.js';\nimport { TemplateColorScheme } from './tmp/rpc/structs/TemplateColorScheme.js';\nimport { TextField } from './tmp/rpc/structs/TextField.js';\nimport { TouchEventCapabilities } from './tmp/rpc/structs/TouchEventCapabilities.js';\nimport { VehicleType } from './tmp/rpc/structs/VehicleType.js';\nimport { VideoStreamingCapability } from './tmp/rpc/structs/VideoStreamingCapability.js';\nimport { VideoStreamingFormat } from './tmp/rpc/structs/VideoStreamingFormat.js';\nimport { SdlServiceListener } from './tmp/session/SdlServiceListener.js';\nimport { SdlSession } from './tmp/session/SdlSession.js';\nimport { SdlSessionListener } from './tmp/session/SdlSessionListener.js';\nimport { ServiceListenerMap } from './tmp/session/ServiceListenerMap.js';\nimport { VideoStreamingParameters } from './tmp/streaming/video/VideoStreamingParameters.js';\nimport { CustomTransport } from './tmp/transport/CustomTransport.js';\nimport { CustomTransportConfig } from './tmp/transport/CustomTransportConfig.js';\nimport { SdlPsm } from './tmp/transport/SdlPsm.js';\nimport { SslConfig } from './tmp/transport/SslConfig.js';\nimport { TransportBase } from './tmp/transport/TransportBase.js';\nimport { TransportCallback } from './tmp/transport/TransportCallback.js';\nimport { TransportConfigBase } from './tmp/transport/TransportConfigBase.js';\nimport { TransportListener } from './tmp/transport/TransportListener.js';\nimport { TransportManager } from './tmp/transport/TransportManager.js';\nimport { TransportManagerBase } from './tmp/transport/TransportManagerBase.js';\nimport { WebSocketClient } from './tmp/transport/WebSocketClient.js';\nimport { WebSocketClientConfig } from './tmp/transport/WebSocketClientConfig.js';\nimport { TransportType } from './tmp/transport/enums/TransportType.js';\nimport { TransportRecord } from './tmp/transport/util/TransportRecord.js';\nimport { ArrayTools } from './tmp/util/ArrayTools.js';\nimport { BitConverter } from './tmp/util/BitConverter.js';\nimport { Bson } from './tmp/util/Bson.js';\nimport { Enum } from './tmp/util/Enum.js';\nimport { JsonRpcMarshaller } from './tmp/util/JsonRpcMarshaller.js';\nimport { TextEncoder } from './tmp/util/TextEncoder.js';\nimport { Version } from './tmp/util/Version.js';\nimport { WebSocketServer } from './tmp/transport/WebSocketServer.js';\nimport { WebSocketServerConfig } from './tmp/transport/WebSocketServerConfig.js';\n\nconst SDL = {\n    manager: {\n        AppConfig,\n        lifecycle: {\n            LifecycleListener,\n            LifecycleManager,\n        },\n    },\n    protocol: {\n        BinaryFrameHeader,\n        MessageFrameAssembler,\n        MessageFrameDisassembler,\n        SdlPacket,\n        SdlPacketFactory,\n        SdlProtocol,\n        SdlProtocolBase,\n        SdlProtocolListener,\n        enums: {\n            ControlFrameTags,\n            FrameType,\n            ServiceType,\n        },\n    },\n    rpc: {\n        RpcCreator,\n        RpcListener,\n        RpcMessage,\n        RpcNotification,\n        RpcRequest,\n        RpcResponse,\n        RpcStruct,\n        enums: {\n            AppHMIType,\n            AudioStreamingState,\n            AudioType,\n            BitsPerSample,\n            ButtonName,\n            CharacterSet,\n            DisplayType,\n            FileType,\n            FunctionID,\n            HMILevel,\n            HmiZoneCapabilities,\n            ImageFieldName,\n            ImageType,\n            Language,\n            MediaClockFormat,\n            MetadataType,\n            PrerecordedSpeech,\n            Result,\n            RpcType,\n            SamplingRate,\n            SoftButtonType,\n            SpeechCapabilities,\n            SystemAction,\n            SystemContext,\n            TextAlignment,\n            TextFieldName,\n            VideoStreamingCodec,\n            VideoStreamingProtocol,\n            VideoStreamingState,\n            VrCapabilities,\n        },\n        messages: {\n            AddCommand,\n            AddCommandResponse,\n            OnHmiStatus,\n            OnLanguageChange,\n            PutFile,\n            PutFileResponse,\n            RegisterAppInterface,\n            RegisterAppInterfaceResponse,\n            SetAppIcon,\n            SetAppIconResponse,\n            Show,\n            ShowResponse,\n            UnregisterAppInterface,\n            UnregisterAppInterfaceResponse,\n        },\n        structs: {\n            AppInfo,\n            AudioPassThruCapabilities,\n            ButtonCapabilities,\n            DeviceInfo,\n            DisplayCapabilities,\n            Grid,\n            HMICapabilities,\n            Image,\n            ImageField,\n            ImageResolution,\n            MenuParams,\n            MetadataTags,\n            ModuleInfo,\n            PresetBankCapabilities,\n            RGBColor,\n            ScreenParams,\n            SdlMsgVersion,\n            SoftButton,\n            SoftButtonCapabilities,\n            TTSChunk,\n            TemplateColorScheme,\n            TextField,\n            TouchEventCapabilities,\n            VehicleType,\n            VideoStreamingCapability,\n            VideoStreamingFormat,\n        },\n    },\n    session: {\n        SdlServiceListener,\n        SdlSession,\n        SdlSessionListener,\n        ServiceListenerMap,\n    },\n    streaming: {\n        video: {\n            VideoStreamingParameters,\n        },\n    },\n    transport: {\n        CustomTransport,\n        CustomTransportConfig,\n        SdlPsm,\n        SslConfig,\n        TransportBase,\n        TransportCallback,\n        TransportConfigBase,\n        TransportListener,\n        TransportManager,\n        TransportManagerBase,\n        WebSocketClient,\n        WebSocketClientConfig,\n        enums: {\n            TransportType,\n        },\n        util: {\n            TransportRecord,\n        },\n        WebSocketServer,\n        WebSocketServerConfig,\n    },\n    util: {\n        ArrayTools,\n        BitConverter,\n        Bson,\n        Enum,\n        JsonRpcMarshaller,\n        TextEncoder,\n        Version,\n    },\n};\n\nexport default SDL;"],"names":["AppConfig","constructor","_transportConfig","_appId","_appName","_iconName","_iconFile","_shortAppName","_ttsName","_vrSynonyms","_isMediaApp","_languageDesired","_hmiDisplayLanguageDesired","_appTypes","_dayColorScheme","_nightColorScheme","_minimumRPCVersion","_minimumProtocolVersion","setTransportConfig","transportConfig","getTransportConfig","setAppId","appId","getAppId","setAppName","appName","getAppName","setAppIcon","iconName","fileData","getAppIconName","getAppIconFileData","setShortAppName","shortAppName","getShortAppName","setTtsName","ttsName","getTtsName","setVrSynonyms","vrSynonyms","getVrSynonyms","setIsMediaApp","isMediaApp","setLanguageDesired","languageDesired","getLanguageDesired","setHmiDisplayLanguageDesired","hmiDisplayLanguageDesired","getHmiDisplayLanguageDesired","setAppTypes","appTypes","getAppTypes","setDayColorScheme","dayColorScheme","getDayColorScheme","setNightColorScheme","nightColorScheme","getNightColorScheme","setMinimumRPCVersion","minimumRPCVersion","getMinimumRPCVersion","setMinimumProtocolVersion","minimumProtocolVersion","getMinimumProtocolVersion","LifecycleListener","_onProxyConnected","_onProxyClosed","_onServiceStarted","_onServiceEnded","_onError","setOnProxyConnected","listener","setOnProxyClosed","setOnServiceStarted","setOnServiceEnded","setOnError","onProxyConnected","lifecycleManager","onProxyClosed","info","reason","onServiceStarted","serviceType","sessionID","correlationID","_onProtocolSessionEndedNACKed","onServiceEnded","onError","Enum","_keyForValue","value","map","key","keyForValue","Error","_valueForKey","valueForKey","RpcStruct","parameters","_isFormatRequested","_rpcSpecVersion","_parameters","getParameters","getParameter","setParameter","getObject","tClass","_formatObject","obj","undefined","String","Object","prototype","Array","length","outArray","item","push","validateType","isArray","name","FunctionID","RegisterAppInterface","_MAP","UnregisterAppInterface","SetGlobalProperties","ResetGlobalProperties","AddCommand","DeleteCommand","AddSubMenu","DeleteSubMenu","CreateInteractionChoiceSet","PerformInteraction","DeleteInteractionChoiceSet","Alert","Show","Speak","SetMediaClockTimer","PerformAudioPassThru","EndAudioPassThru","SubscribeButton","UnsubscribeButton","SubscribeVehicleData","UnsubscribeVehicleData","GetVehicleData","ReadDID","GetDTCs","ScrollableMessage","Slider","ShowConstantTBT","AlertManeuver","UpdateTurnList","ChangeRegistration","GenericResponse","PutFile","DeleteFile","ListFiles","SetAppIcon","SetDisplayLayout","DiagnosticMessage","SystemRequest","SendLocation","DialNumber","ButtonPress","GetInteriorVehicleData","SetInteriorVehicleData","GetWayPoints","SubscribeWayPoints","UnsubscribeWayPoints","GetSystemCapability","SendHapticData","SetCloudAppProperties","GetCloudAppProperties","PublishAppService","GetAppServiceData","GetFile","PerformAppServiceInteraction","UnpublishAppService","CancelInteraction","CloseApplication","ShowAppMenu","CreateWindow","DeleteWindow","GetInteriorVehicleDataConsent","ReleaseInteriorVehicleDataModule","OnHMIStatus","OnAppInterfaceUnregistered","OnButtonEvent","OnButtonPress","OnVehicleData","OnCommand","OnTBTClientState","OnDriverDistraction","OnPermissionsChange","OnAudioPassThru","OnLanguageChange","OnKeyboardInput","OnTouchEvent","OnSystemRequest","OnHashChange","OnInteriorVehicleData","OnWayPointChange","OnRCStatus","OnAppServiceData","OnSystemCapabilityUpdated","freeze","RpcMessage","store","_isEncrypted","_rpcType","rpcType","_functionName","functionName","_correlationID","setBulkData","bulkData","getRPCType","setRPCType","type","getFunctionName","setFunctionName","getCorrelationId","setCorrelationId","id","getBulkData","_bulkData","data","slice","getIsEncrypted","setIsEncrypted","bool","RpcType","NOTIFICATION","RESPONSE","REQUEST","RpcRequest","_promise","getOnRPCResponsePromise","setOnRPCResponsePromise","promise","Promise","SdlMsgVersion","setMajorVersion","KEY_MAJOR_VERSION","getMajorVersion","setMinorVersion","KEY_MINOR_VERSION","getMinorVersion","setPatchVersion","KEY_PATCH_VERSION","getPatchVersion","SpeechCapabilities","SC_TEXT","SAPI_PHONEMES","LHPLUS_PHONEMES","PRE_RECORDED","SILENCE","FILE","TTSChunk","setText","text","KEY_TEXT","getText","setType","KEY_TYPE","getType","DeviceInfo","setHardware","hardware","KEY_HARDWARE","getHardware","setFirmwareRev","firmwareRev","KEY_FIRMWARE_REV","getFirmwareRev","setOs","os","KEY_OS","getOs","setOsVersion","osVersion","KEY_OS_VERSION","getOsVersion","setCarrier","carrier","KEY_CARRIER","getCarrier","setMaxNumberRFCOMMPorts","maxNumberRFCOMMPorts","Number","KEY_MAX_NUMBER_RFCOMM_PORTS","getMaxNumberRFCOMMPorts","AppInfo","setAppDisplayName","appDisplayName","KEY_APP_DISPLAY_NAME","getAppDisplayName","setAppBundleID","appBundleID","KEY_APP_BUNDLE_ID","getAppBundleID","setAppVersion","appVersion","KEY_APP_VERSION","getAppVersion","appIcon","KEY_APP_ICON","getAppIcon","RGBColor","setRedValue","redValue","KEY_RED","getRedValue","setGreenValue","greenValue","KEY_GREEN","getGreenValue","setBlueValue","blueValue","KEY_BLUE","getBlueValue","TemplateColorScheme","setPrimaryColor","primaryColor","KEY_PRIMARY_COLOR","getPrimaryColor","setSecondaryColor","secondaryColor","KEY_SECONDARY_COLOR","getSecondaryColor","setBackgroundColor","backgroundColor","KEY_BACKGROUND_COLOR","getBackgroundColor","Language","EN_SA","HE_IL","RO_RO","UK_UA","ID_ID","VI_VN","MS_MY","HI_IN","NL_BE","EL_GR","HU_HU","FI_FI","SK_SK","EN_US","ES_MX","FR_CA","DE_DE","ES_ES","EN_GB","RU_RU","TR_TR","PL_PL","FR_FR","IT_IT","SV_SE","PT_PT","NL_NL","EN_AU","ZH_CN","ZH_TW","JA_JP","AR_SA","KO_KR","PT_BR","CS_CZ","DA_DK","NO_NO","EN_IN","TH_TH","AppHMIType","DEFAULT","COMMUNICATION","MEDIA","MESSAGING","NAVIGATION","INFORMATION","SOCIAL","BACKGROUND_PROCESS","TESTING","SYSTEM","PROJECTION","REMOTE_CONTROL","setSdlMsgVersion","sdlMsgVersion","KEY_SDL_MSG_VERSION","getSdlMsgVersion","KEY_APP_NAME","ttsNames","KEY_TTS_NAME","setNgnMediaScreenAppName","ngnppName","KEY_NGN_MEDIA_SCREEN_APP_NAME","getNgnMediaScreenAppName","KEY_VR_SYNONYMS","setIsMediaApplication","isMediaApplication","KEY_IS_MEDIA_APPLICATION","getIsMediaApplication","KEY_LANGUAGE_DESIRED","KEY_HMI_DISPLAY_LANGUAGE_DESIRED","setAppHmiType","appHMIType","KEY_APP_HMI_TYPE","getAppHmiType","setHashID","hashID","KEY_HASH_ID","getHashID","setDeviceInfo","deviceInfo","KEY_DEVICE_INFO","getDeviceInfo","_setAppId","KEY_APP_ID","setFullAppId","fullAppId","toLowerCase","KEY_FULL_APP_ID","APP_ID_MAX_LENGTH","replace","substring","getFullAppId","setAppInfo","appInfo","KEY_APP_INFO","getAppInfo","KEY_DAY_COLOR_SCHEME","KEY_NIGHT_COLOR_SCHEME","KEY_SYNC_MSG_VERSION","Result","SUCCESS","UNSUPPORTED_REQUEST","UNSUPPORTED_RESOURCE","DISALLOWED","REJECTED","ABORTED","IGNORED","RETRY","IN_USE","VEHICLE_DATA_NOT_AVAILABLE","TIMED_OUT","INVALID_DATA","CHAR_LIMIT_EXCEEDED","INVALID_ID","DUPLICATE_NAME","APPLICATION_NOT_REGISTERED","WRONG_LANGUAGE","OUT_OF_MEMORY","TOO_MANY_PENDING_REQUESTS","TOO_MANY_APPLICATIONS","APPLICATION_REGISTERED_ALREADY","WARNINGS","GENERIC_ERROR","USER_DISALLOWED","TRUNCATED_DATA","UNSUPPORTED_VERSION","VEHICLE_DATA_NOT_ALLOWED","FILE_NOT_FOUND","CANCEL_ROUTE","SAVED","INVALID_CERT","EXPIRED_CERT","RESUME_FAILED","DATA_NOT_AVAILABLE","READ_ONLY","CORRUPTED_DATA","RpcResponse","getSuccess","KEY_SUCCESS","setSuccess","success","getInfo","KEY_INFO","setInfo","getResultCode","KEY_RESULT_CODE","setResultCode","resultCode","RpcListener","_onRpcMessage","setOnRpcMessage","func","onRpcMessage","rpcMessage","SdlProtocolListener","_onRpcMessageReceived","_onProtocolSessionStarted","_onProtocolSessionEnded","_getSessionId","_onTransportConnected","setOnTransportConnected","setOnRpcMessageReceived","onRpcMessageReceived","setOnProtocolSessionStarted","onTransportConnected","onProtocolSessionStarted","sessionId","version","correlationId","hashId","isEncrypted","setOnProtocolSessionEnded","onProtocolSessionEnded","setOnProtocolSessionEndedNACKed","onProtocolSessionEndedNACKed","setGetSessionId","getter","getSessionId","setGetDesiredVideoParams","_getDesiredVideoParams","getDesiredVideoParams","setSetAcceptedVideoParams","setter","_setAcceptedVideoParams","setAcceptedVideoParams","params","FrameType","CONTROL","FIRST","CONSECUTIVE","SINGLE","exports","modules","installedModules","__webpack_require__","moduleId","module","i","l","call","m","c","d","o","defineProperty","configurable","enumerable","get","n","__esModule","getDefault","getModuleExports","object","property","hasOwnProperty","p","s","g","Function","eval","e","window","global","base64","ieee754","Buffer","SlowBuffer","INSPECT_MAX_BYTES","TYPED_ARRAY_SUPPORT","typedArraySupport","kMaxLength","arr","Uint8Array","__proto__","foo","subarray","byteLength","createBuffer","that","RangeError","arg","encodingOrOffset","allocUnsafe","from","poolSize","_augment","TypeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","Symbol","species","assertSize","size","alloc","fill","encoding","checked","allocUnsafeSlow","string","isEncoding","actual","write","fromArrayLike","array","byteOffset","isBuffer","len","copy","buffer","isnan","toString","b","_isBuffer","compare","a","x","y","Math","min","concat","list","pos","buf","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","swap16","swap32","swap64","arguments","apply","equals","inspect","str","max","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","bidirectionalIndexOf","val","dir","isNaN","arrayIndexOf","indexOf","lastIndexOf","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","j","includes","hexWrite","offset","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","isFinite","toJSON","_arr","fromByteArray","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","decodeCodePointsArray","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","ret","out","toHex","bytes","newBuf","sliceLen","checkOffset","ext","readUIntLE","noAssert","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","checkInt","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","objectWriteUInt16","littleEndian","writeUInt16LE","writeUInt16BE","objectWriteUInt32","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","checkIEEE754","writeFloat","writeFloatLE","writeFloatBE","writeDouble","writeDoubleLE","writeDoubleBE","targetStart","set","code","charCodeAt","INVALID_BASE64_RE","base64clean","stringtrim","trim","units","Infinity","leadSurrogate","byteArray","hi","lo","toByteArray","src","dst","factory","long","commonjsGlobal","self","createCommonjsModule","fn","getCjsExportFromNamespace","Map","_keys","_values","entry","v","clear","splice","entries","index","next","done","forEach","callback","has","keys","values","map_1","toExtendedJSON","options","relaxed","toNumber","$numberLong","fromExtendedJSON","doc","result","long_1","_classCallCheck","instance","Constructor","_defineProperties","props","descriptor","writable","_createClass","protoProps","staticProps","Double","valueOf","$numberDouble","parseFloat","double_1","_typeof","_typeof2","iterator","_classCallCheck$1","_defineProperties$1","_createClass$1","_possibleConstructorReturn","_assertThisInitialized","ReferenceError","_getPrototypeOf","setPrototypeOf","getPrototypeOf","_inherits","subClass","superClass","create","_setPrototypeOf","Timestamp","_Long","low","high","_this","isLong","$timestamp","t","fromInt","fromNumber","fromBits","lowBits","highBits","opt_radix","timestamp","empty","empty$1","require$$0","normalizedFunctionString","insecureRandomBytes","random","randomBytes","crypto","getRandomValues","utils","setTimeout","clearTimeout","performance","performanceNow","now","mozNow","msNow","oNow","webkitNow","Date","getTime","inherits","ctor","superCtor","super_","TempCtor","inherits$1","_typeof$1","formatRegExp","format","f","isString","objects","args","JSON","stringify","_","isNull","isObject","deprecate","msg","isUndefined","process","warned","deprecated","console","error","debugs","debugEnviron","debuglog","toUpperCase","RegExp","test","pid","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","customInspect","stylizeWithColor","formatValue","styles","styleType","style","arrayToHash","hash","idx","recurseTimes","isFunction","primitive","formatPrimitive","visibleKeys","getOwnPropertyNames","isError","formatError","isRegExp","isDate","base","braces","toUTCString","output","formatArray","formatProperty","pop","reduceToSingleString","simple","isNumber","desc","getOwnPropertyDescriptor","split","line","reduce","prev","cur","ar","isNullOrUndefined","isSymbol","re","objectToString","isPrimitive","maybeBuf","pad","months","timestamp$1","time","getHours","getMinutes","getSeconds","getDate","getMonth","log","origin","add","prop","util","util$1","util$2","_classCallCheck$2","_defineProperties$2","_createClass$2","Buffer$1","randomBytes$1","deprecate$1","PROCESS_UNIQUE","checkForHexRegExp","hasBufferType","err","hexTable","_i","decodeLookup","_Buffer","convertToHex","makeObjectIdError","invalidString","invalidCharacter","ObjectId","generate","cacheHexString","__id","valid","isValid","createFromHexString","toHexString","hexString","_i2","hexChar","otherId","getTimestamp","setTime","$oid","getInc","inc","buffer$$1","createPk","createFromTime","get_inc","custom","objectid","_classCallCheck$3","_defineProperties$3","_createClass$3","alphabetize","sort","BSONRegExp","pattern","$regularExpression","regexp","_classCallCheck$4","_defineProperties$4","_createClass$4","BSONSymbol","$symbol","symbol","_classCallCheck$5","_defineProperties$5","_createClass$5","Int32","$numberInt","int_32","_classCallCheck$6","_defineProperties$6","_createClass$6","Code","scope","$code","$scope","Buffer$2","PARSE_STRING_REGEXP","PARSE_INF_REGEXP","PARSE_NAN_REGEXP","EXPONENT_MAX","EXPONENT_MIN","EXPONENT_BIAS","MAX_DIGITS","NAN_BUFFER","reverse","INF_NEGATIVE_BUFFER","INF_POSITIVE_BUFFER","EXPONENT_REGEX","isDigit","divideu128","DIVISOR","_rem","parts","quotient","rem","shiftLeft","div","modulo","multiply64x2","left","right","leftHigh","shiftRightUnsigned","leftLow","getLowBits","rightHigh","rightLow","productHigh","multiply","productMid","productMid2","productLow","lessThan","uhleft","uhright","ulleft","ulright","invalidErr","message","Decimal128","isNegative","sawRadix","foundNonZero","significantDigits","nDigitsRead","nDigits","radixPosition","firstNonZero","digits","nDigitsStored","digitsInsert","firstDigit","lastDigit","exponent","significandHigh","significandLow","biasedExponent","stringMatch","infMatch","nanMatch","unsignedNumber","expSign","expNumber","digitsString","_digitsString","endOfString","roundDigit","roundBit","dIdx","_dIdx","_dIdx2","significand","dec","and","or","COMBINATION_MASK","EXPONENT_MASK","COMBINATION_INFINITY","COMBINATION_NAN","midh","midl","combination","biased_exponent","significand_digits","scientific_exponent","is_zero","significand_msb","significand128","k","ZERO","least_digits","radix_position","_i3","_i4","$numberDecimal","decimal128","_classCallCheck$7","_defineProperties$7","_createClass$7","MinKey","$minKey","min_key","_classCallCheck$8","_defineProperties$8","_createClass$8","MaxKey","$maxKey","max_key","_classCallCheck$9","_defineProperties$9","_createClass$9","DBRef","collection","oid","db","fields","shift","assign","$ref","$id","$db","db_ref","_classCallCheck$a","_defineProperties$a","_createClass$a","Buffer$3","Binary","subType","sub_type","BSON_BINARY_SUBTYPE_DEFAULT","position","writeStringToArray","BUFFER_SIZE","put","byte_value","decoded_byte","_buffer","isUint8Array","asRaw","newBuffer","convertArraytoUtf8BinaryString","base64String","$binary","startIndex","endIndex","SUBTYPE_DEFAULT","SUBTYPE_FUNCTION","SUBTYPE_BYTE_ARRAY","SUBTYPE_UUID_OLD","SUBTYPE_UUID","SUBTYPE_MD5","SUBTYPE_USER_DEFINED","binary","constants","BSON_INT32_MAX","BSON_INT32_MIN","BSON_INT64_MAX","BSON_INT64_MIN","JS_INT_MAX","JS_INT_MIN","BSON_DATA_NUMBER","BSON_DATA_STRING","BSON_DATA_OBJECT","BSON_DATA_ARRAY","BSON_DATA_BINARY","BSON_DATA_UNDEFINED","BSON_DATA_OID","BSON_DATA_BOOLEAN","BSON_DATA_DATE","BSON_DATA_NULL","BSON_DATA_REGEXP","BSON_DATA_DBPOINTER","BSON_DATA_CODE","BSON_DATA_SYMBOL","BSON_DATA_CODE_W_SCOPE","BSON_DATA_INT","BSON_DATA_TIMESTAMP","BSON_DATA_LONG","BSON_DATA_DECIMAL128","BSON_DATA_MIN_KEY","BSON_DATA_MAX_KEY","BSON_BINARY_SUBTYPE_FUNCTION","BSON_BINARY_SUBTYPE_BYTE_ARRAY","BSON_BINARY_SUBTYPE_UUID","BSON_BINARY_SUBTYPE_MD5","BSON_BINARY_SUBTYPE_USER_DEFINED","_typeof$2","keysToCodecs","deserializeValue","$undefined","filter","startsWith","$date","date","parse","$dbPointer","dollarKeys","strict","replacer","space","serializeArray","serializeDocument","serialize","bson","deserialize","ejson","serializeValue","getISOString","isoStr","toISOString","getUTCMilliseconds","dateNum","inRange","int32Range","int64Range","flags","rx","source","BSON_TYPE_MAPPINGS","subtype","namespace","Long","low_","high_","unsigned","unsigned_","ObjectID","bsontype","_bsontype","_doc","_doc2","mapper","extended_json","FIRST_BIT","FIRST_TWO_BITS","FIRST_THREE_BITS","FIRST_FOUR_BITS","FIRST_FIVE_BITS","TWO_BIT_CHAR","THREE_BIT_CHAR","FOUR_BIT_CHAR","CONTINUING_CHAR","validateUtf8","continuation","byte","validateUtf8_1","validate_utf8","Buffer$4","validateUtf8$1","JS_INT_MAX_LONG","JS_INT_MIN_LONG","functionCache","deserialize$1","allowObjectSmallerThanBufferSize","deserializeObject","evalFunctions","cacheFunctions","cacheFunctionsCrc32","crc32","fieldsAsRaw","raw","bsonRegExp","promoteBuffers","promoteLongs","promoteValues","arrayIndex","elementType","stringSize","_index","objectSize","_index2","_objectSize","arrayOptions","stopIndex","_lowBits","_highBits","long$$1","lessThanOrEqual","greaterThanOrEqual","decimal128$$1","toObject","binarySize","totalBinarySize","regExpOptions","optionsArray","_source","_regExpOptions","_stringSize","_lowBits2","_highBits2","_stringSize2","functionString","isolateEvalWithHash","isolateEval","totalSize","_stringSize3","_functionString","_index3","_objectSize2","scopeObject","_hash","_stringSize4","oidBuffer","_oid","bind","deserializer","readIEEE754","endian","mLen","nBytes","bBE","eLen","eMax","eBias","nBits","NaN","writeIEEE754","rt","abs","LN2","float_parser","_typeof$3","Buffer$5","writeIEEE754$1","normalizedFunctionString$1","regexp$1","ignoreKeys","Set","isDate$1","isRegExp$1","serializeString","numberOfWrittenBytes","serializeNumber","_numberOfWrittenBytes","_numberOfWrittenBytes2","longVal","getHighBits","_numberOfWrittenBytes3","serializeNull","serializeBoolean","serializeDate","dateInMilis","serializeRegExp","ignoreCase","multiline","serializeBSONRegExp","serializeMinMax","serializeObjectId","serializeBuffer","serializeObject","checkKeys","serializeFunctions","ignoreUndefined","path","serializeInto","serializeDecimal128","serializeLong","serializeInt32","serializeDouble","serializeFunction","serializeCode","codeSize","_numberOfWrittenBytes4","serializeBinary","serializeSymbol","serializeDBRef","startingIndex","toBSON","_key","_value","_type","_key2","_value2","_type2","serializer","_typeof$4","Buffer$6","normalizedFunctionString$2","isDate$2","calculateObjectSize","totalLength","calculateElement","ordered_values","calculate_size","Buffer$7","ensure_buffer","ensureBuffer","potentialBuffer","Buffer$8","MAXSIZE","buffer$1","setInternalBufferSize","serialize$1","minInternalBufferSize","serializationIndex","finishedBuffer","serializeWithBufferAndIndex","finalBuffer","deserialize$2","calculateObjectSize$1","deserializeStream","numberOfDocuments","documents","docStartIndex","EJSON","bson_1","bson_2","bson_3","bson_4","bson_5","bson_6","bson_7","bson_8","bson_9","bson_10","bson_11","bson_12","bson_13","bson_14","bson_15","bson_16","bson_17","bson_18","bson_19","bson_20","bson_21","bson_22","bson_23","bson_24","bson_25","bson_26","bson_27","bson_28","bson_29","bson_30","bson_31","bson_32","bson_33","bson_34","bson_35","bson_36","bson_37","bson_38","bson_39","bson_40","bson_41","bson_42","bson_43","bson_44","bson_45","bson_46","bson_47","bson_48","bson_49","bson_50","bson_51","bson_52","bson_53","bson_54","lookup","revLookup","Arr","getLens","b64","validLen","placeHoldersLen","lens","_byteLength","tmp","curByte","tripletToBase64","num","encodeChunk","uint8","extraBytes","maxChunkLength","len2","isLE","wasm","WebAssembly","Instance","Module","__isLong__","INT_CACHE","UINT_CACHE","cachedObj","cache","UZERO","TWO_PWR_64_DBL","MAX_UNSIGNED_VALUE","TWO_PWR_63_DBL","MIN_VALUE","MAX_VALUE","neg","TWO_PWR_32_DBL","pow_dbl","radix","radixToPower","power","fromValue","TWO_PWR_16_DBL","TWO_PWR_24_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","LongPrototype","toInt","isZero","eq","radixLong","rem1","remDiv","intval","getHighBitsUnsigned","getLowBitsUnsigned","getNumBitsAbs","bit","eqz","isPositive","isOdd","isEven","other","notEquals","neq","ne","comp","lt","lte","le","greaterThan","gt","gte","ge","thisNeg","otherNeg","negate","not","addend","a48","a32","a16","a00","b48","b32","b16","b00","c48","c32","c16","c00","subtract","subtrahend","multiplier","get_high","divide","divisor","div_u","div_s","approx","halfThis","shr","shl","toUnsigned","shru","log2","ceil","delta","approxRes","approxRem","rem_u","rem_s","mod","xor","numBits","shiftRight","shr_u","toSigned","toBytes","toBytesLE","toBytesBE","fromBytes","fromBytesLE","fromBytesBE","BSON","Bson","SdlPacket","encryption","frameType","frameInfo","dataSize","messageID","payload","bytesToWrite","_version","_encryption","_frameType","_serviceType","_frameInfo","_sessionID","_dataSize","_messageID","_payload","_offset","_bytesToWrite","_bsonPayload","getVersion","getEncryption","getServiceType","getFrameInfo","getSessionID","getMessageID","getDataSize","setPayload","getPayload","getEncryptionBit","_ENCRYPTION_MASK","getFrameType","_constructPacket","controlFrameInfo","dataView","dataViewIndex","_HEADER_SIZE","_HEADER_SIZE_V1","toPacket","putTag","tag","getTag","_EXTRA_PARCEL_DATA_LENGTH","SERVICE_TYPE_CONTROL","SERVICE_TYPE_RPC","SERVICE_TYPE_PCM","SERVICE_TYPE_VIDEO","SERVICE_TYPE_BULK_DATA","FRAME_INFO_HEART_BEAT","FRAME_INFO_START_SERVICE","FRAME_INFO_START_SERVICE_ACK","FRAME_INFO_START_SERVICE_NAK","FRAME_INFO_END_SERVICE","FRAME_INFO_END_SERVICE_ACK","FRAME_INFO_END_SERVICE_NAK","FRAME_INFO_REGISTER_SECONDARY_TRANSPORT","FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_ACK","FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_NAK","FRAME_INFO_TRANSPORT_EVENT_UPDATE","FRAME_INFO_SERVICE_DATA_ACK","FRAME_INFO_HEART_BEAT_ACK","FRAME_INFO_FINAL_CONNESCUTIVE_FRAME","FRAME_INFO_RESERVED","base64.fromByteArray","ieee754.read","ieee754.write","base64.toByteArray","TextEncoder","encode","Len","resPos","resArr","point","nextcode","JsonRpcMarshaller","marshall","rpcStruct","jsonBytes","paramify","jsonObject","stringVersion","_encode","unmarshall","jsonString","_decode","BinaryFrameHeader","functionId","jsonSize","_functionId","_correlationId","_jsonSize","_jsonData","fromBinaryHeader","binaryFrameHeaderData","binaryFrameHeader","jsonDataStart","HEADER_SIZE","jsonDataEnd","setJsonData","assembleHeaderBytes","setRpcType","getRpcType","setFunctionId","getFunctionId","setJsonSize","getJsonSize","getJsonData","MessageFrameDisassembler","rpcRequest","messageId","mtu","packetCallback","_rpcRequest","_sessionId","_messageId","_mtu","_packetCallback","buildRPC","cb","_doRequest","_buildRPCMainBuffer","rpcBulkData","jsonBuffer","bfh","headerSize","bulkDataSize","totalMessageSize","mainBuffer","frameCount","fullPacket","view","DataView","setUint32","firstHeader","_buildConsecutiveFrames","sdlPacket","frameSequenceNumber","count","header","TransportListener","_onTransportDisconnected","_onPacketReceived","setOnTransportDisconnected","setOnPacketReceived","onTransportDisconnected","onPacketReceived","Version","major","minor","patch","setMajor","setMinor","setPatch","_major","getMajor","_minor","getMinor","_patch","getPatch","versions","isNewerThan","ServiceType","RPC","AUDIO","VIDEO","HYBRID","MessageFrameAssembler","_callback","_accumulator","_totalConsecutiveFrames","_consecutiveFramesHandledCount","_consecutiveFramesDataLength","handleFrame","_handleMultiFrameMessage","_handleFirstDataFrame","dataLength","_handleConsecutiveFrame","frameSequence","warn","finishedSdlPacket","ControlFrameTags","StartServiceACKBase","MTU","NAKBase","REJECTED_PARAMS","StartServiceProtocolVersion","PROTOCOL_VERSION","StartServiceHashId","HASH_ID","StartServiceDimensions","HEIGHT","WIDTH","StartService","StartServiceACK","SECONDARY_TRANSPORTS","AUDIO_SERVICE_TRANSPORTS","VIDEO_SERVICE_TRANSPORTS","AUTH_TOKEN","StartServiceNAK","EndService","EndServiceACK","EndServiceNAK","TransportEventUpdate","TCP_IP_ADDRESS","TCP_PORT","RegisterSecondaryTransport","RegisterSecondaryTransportACK","RegisterSecondaryTransportNAK","REASON","Audio","Video","VIDEO_PROTOCOL","VIDEO_CODEC","BitConverter","arrayBufferToInt32","getUint32","int32ToArrayBuffer","SdlPacketFactory","createHeartbeatACK","createEndSession","endSession","ImageType","STATIC","DYNAMIC","Image","setValue","KEY_VALUE","getValue","setImageType","KEY_IMAGE_TYPE","getImageType","setIsTemplate","isTemplate","KEY_IS_TEMPLATE","getIsTemplate","MenuParams","setParentID","KEY_PARENT_ID","getParentID","setPosition","KEY_POSITION","getPosition","setMenuName","menuName","KEY_MENU_NAME","getMenuName","setCmdID","KEY_CMD_ID","getCmdID","setMenuParams","menuParams","KEY_MENU_PARAMS","getMenuParams","setVrCommands","vrCommands","KEY_VR_COMMANDS","getVrCommands","setCmdIcon","icon","KEY_CMD_ICON","getCmdIcon","AddCommandResponse","RpcNotification","HMILevel","HMI_FULL","HMI_LIMITED","HMI_BACKGROUND","HMI_NONE","AudioStreamingState","AUDIBLE","ATTENUATED","NOT_AUDIBLE","VideoStreamingState","STREAMABLE","NOT_STREAMABLE","SystemContext","SYSCTXT_MAIN","SYSCTXT_VRSESSION","SYSCTXT_MENU","SYSCTXT_HMI_OBSCURED","SYSCTXT_ALERT","OnHmiStatus","setHMILevel","hmiLevel","KEY_HMI_LEVEL","getHMILevel","setAudioStreamingState","audioStreamingState","KEY_AUDIO_STREAMING_STATE","getAudioStreamingState","setSystemContext","systemContext","KEY_SYSTEM_CONTEXT","getSystemContext","setVideoStreamingState","videoStreamingState","KEY_VIDEO_STREAMING_STATE","getVideoStreamingState","setWindowID","windowID","KEY_WINDOW_ID","getWindowID","setLanguage","language","KEY_LANGUAGE","getLanguage","setHMIDisplayLanguage","KEY_HMI_DISPLAY_LANGUAGE","getHMIDisplayLanguage","FileType","GRAPHIC_BMP","GRAPHIC_JPEG","GRAPHIC_PNG","AUDIO_WAVE","AUDIO_AAC","BINARY","setFileData","getFileData","setFileName","fileName","KEY_FILE_NAME","getFileName","setFileType","fileType","KEY_FILE_TYPE","getFileType","setPersistentFile","persistentFile","KEY_PERSISTENT_FILE","getPersistentFile","setSystemFile","systemFile","KEY_SYSTEM_FILE","getSystemFile","setOffset","KEY_OFFSET","getOffset","setLength","KEY_LENGTH","getLength","setCRC","crc","KEY_CRC","getCRC","PutFileResponse","setSpaceAvailable","spaceAvailable","KEY_SPACE_AVAILABLE","getSpaceAvailable","TextFieldName","mainField1","mainField2","mainField3","mainField4","statusBar","mediaClock","mediaTrack","templateTitle","alertText1","alertText2","alertText3","scrollableMessageBody","initialInteractionText","navigationText1","navigationText2","ETA","totalDistance","audioPassThruDisplayText1","audioPassThruDisplayText2","sliderHeader","sliderFooter","secondaryText","tertiaryText","menuTitle","locationName","locationDescription","addressLines","phoneNumber","CharacterSet","TYPE2SET","TYPE5SET","CID1SET","CID2SET","TextField","setTextFieldName","textFieldName","KEY_NAME","getTextFieldName","setCharacterSet","characterSet","KEY_CHARACTER_SET","getCharacterSet","setWidth","width","KEY_WIDTH","getWidth","setRows","rows","KEY_ROWS","getRows","ImageResolution","setResolutionWidth","resolutionWidth","KEY_RESOLUTION_WIDTH","getResolutionWidth","setResolutionHeight","resolutionHeight","KEY_RESOLUTION_HEIGHT","getResolutionHeight","ImageFieldName","softButtonImage","choiceImage","choiceSecondaryImage","vrHelpItem","turnIcon","menuIcon","cmdIcon","graphic","secondaryGraphic","showConstantTBTIcon","showConstantTBTNextTurnIcon","locationImage","alertIcon","ImageField","setImageFieldName","imageFieldName","getImageFieldName","setImageTypeSupported","imageTypeSupported","KEY_IMAGE_TYPE_SUPPORTED","getImageTypeSupported","setImageResolution","imageResolution","KEY_IMAGE_RESOLUTION","getImageResolution","TouchEventCapabilities","setPressAvailable","pressAvailable","KEY_PRESS_AVAILABLE","getPressAvailable","setMultiTouchAvailable","multiTouchAvailable","KEY_MULTI_TOUCH_AVAILABLE","getMultiTouchAvailable","setDoublePressAvailable","doublePressAvailable","KEY_DOUBLE_PRESS_AVAILABLE","getDoublePressAvailable","ScreenParams","setResolution","resolution","KEY_RESOLUTION","getResolution","setTouchEventAvailable","touchEventCapabilities","KEY_TOUCH_EVENT_AVAILABLE","getTouchEventAvailable","DisplayType","CID","TYPE2","TYPE5","NGN","GEN2_8_DMA","GEN2_6_DMA","MFD3","MFD4","MFD5","GEN3_8_INCH","SDL_GENERIC","MediaClockFormat","CLOCK1","CLOCK2","CLOCK3","CLOCKTEXT1","CLOCKTEXT2","CLOCKTEXT3","CLOCKTEXT4","DisplayCapabilities","setDisplayType","displayType","KEY_DISPLAY_TYPE","getDisplayType","setDisplayName","displayName","KEY_DISPLAY_NAME","getDisplayName","setTextFields","textFields","KEY_TEXT_FIELDS","getTextFields","setImageFields","imageFields","KEY_IMAGE_FIELDS","getImageFields","setMediaClockFormats","mediaClockFormats","KEY_MEDIA_CLOCK_FORMATS","getMediaClockFormats","setGraphicsSupported","graphicSupported","KEY_GRAPHICS_SUPPORTED","getGraphicsSupported","setTemplatesAvailable","templatesAvailable","KEY_TEMPLATES_AVAILABLE","getTemplatesAvailable","setScreenParams","screenParams","KEY_SCREEN_PARAMS","getScreenParams","setNumCustomPresetsAvailable","numCustomPresetsAvailable","KEY_NUM_CUSTOM_PRESETS_AVAILABLE","getNumCustomPresetsAvailable","Grid","setColumn","column","KEY_COLUMN","getColumn","setRow","row","KEY_ROW","getRow","setLevel","level","KEY_LEVEL","getLevel","setColumnSpan","columnSpan","KEY_COLUMN_SPAN","getColumnSpan","setRowSpan","rowSpan","KEY_ROW_SPAN","getRowSpan","setLevelSpan","levelSpan","KEY_LEVEL_SPAN","getLevelSpan","ModuleInfo","setModuleId","KEY_MODULE_ID","getModuleId","setLocation","location","KEY_LOCATION","getLocation","setServiceArea","serviceArea","KEY_SERVICE_AREA","getServiceArea","setAllowMultipleAccess","allowMultipleAccess","KEY_ALLOW_MULTIPLE_ACCESS","getAllowMultipleAccess","ButtonName","OK","PLAY_PAUSE","SEEKLEFT","SEEKRIGHT","TUNEUP","TUNEDOWN","PRESET_0","PRESET_1","PRESET_2","PRESET_3","PRESET_4","PRESET_5","PRESET_6","PRESET_7","PRESET_8","PRESET_9","CUSTOM_BUTTON","SEARCH","AC_MAX","AC","RECIRCULATE","FAN_UP","FAN_DOWN","TEMP_UP","TEMP_DOWN","DEFROST_MAX","DEFROST","DEFROST_REAR","UPPER_VENT","LOWER_VENT","VOLUME_UP","VOLUME_DOWN","EJECT","SOURCE","SHUFFLE","REPEAT","NAV_CENTER_LOCATION","NAV_ZOOM_IN","NAV_ZOOM_OUT","NAV_PAN_UP","NAV_PAN_UP_RIGHT","NAV_PAN_RIGHT","NAV_PAN_DOWN_RIGHT","NAV_PAN_DOWN","NAV_PAN_DOWN_LEFT","NAV_PAN_LEFT","NAV_PAN_UP_LEFT","NAV_TILT_TOGGLE","NAV_ROTATE_CLOCKWISE","NAV_ROTATE_COUNTERCLOCKWISE","NAV_HEADING_TOGGLE","ButtonCapabilities","setName","getName","setModuleInfo","moduleInfo","KEY_MODULE_INFO","getModuleInfo","setShortPressAvailable","shortPressAvailable","KEY_SHORT_PRESS_AVAILABLE","getShortPressAvailable","setLongPressAvailable","longPressAvailable","KEY_LONG_PRESS_AVAILABLE","getLongPressAvailable","setUpDownAvailable","upDownAvailable","KEY_UP_DOWN_AVAILABLE","getUpDownAvailable","SoftButtonCapabilities","setImageSupported","imageSupported","KEY_IMAGE_SUPPORTED","getImageSupported","setTextSupported","textSupported","KEY_TEXT_SUPPORTED","getTextSupported","PresetBankCapabilities","setOnScreenPresetsAvailable","onScreenPresetsAvailable","KEY_ON_SCREEN_PRESETS_AVAILABLE","getOnScreenPresetsAvailable","VehicleType","setMake","make","KEY_MAKE","getMake","setModel","model","KEY_MODEL","getModel","setModelYear","modelYear","KEY_MODEL_YEAR","getModelYear","setTrim","KEY_TRIM","getTrim","HmiZoneCapabilities","FRONT","BACK","PrerecordedSpeech","HELP_JINGLE","INITIAL_JINGLE","LISTEN_JINGLE","POSITIVE_JINGLE","NEGATIVE_JINGLE","SamplingRate","SamplingRate_8KHZ","SamplingRate_16KHZ","SamplingRate_22KHZ","SamplingRate_44KHZ","BitsPerSample","BitsPerSample_8_BIT","BitsPerSample_16_BIT","AudioType","PCM","AudioPassThruCapabilities","setSamplingRate","samplingRate","KEY_SAMPLING_RATE","getSamplingRate","setBitsPerSample","bitsPerSample","KEY_BITS_PER_SAMPLE","getBitsPerSample","setAudioType","audioType","KEY_AUDIO_TYPE","getAudioType","VrCapabilities","VR_TEXT","HMICapabilities","setNavigation","navigation","KEY_NAVIGATION","getNavigation","setPhoneCall","phoneCall","KEY_PHONE_CALL","getPhoneCall","setVideoStreaming","videoStreaming","KEY_VIDEO_STREAMING","getVideoStreaming","setRemoteControl","remoteControl","KEY_REMOTE_CONTROL","getRemoteControl","setAppService","appServices","KEY_APP_SERVICES","getAppService","setDisplays","displays","KEY_DISPLAYS","getDisplays","setSeatLocation","seatLocation","KEY_SEAT_LOCATION","getSeatLocation","RegisterAppInterfaceResponse","setHmiDisplayLanguage","hmiDisplayLanguage","getHmiDisplayLanguage","setDisplayCapabilities","displayCapabilities","KEY_DISPLAY_CAPABILITIES","getDisplayCapabilities","setButtonCapabilities","buttonCapabilities","KEY_BUTTON_CAPABILITIES","getButtonCapabilities","setSoftButtonCapabilities","softButtonCapabilities","KEY_SOFT_BUTTON_CAPABILITIES","getSoftButtonCapabilities","setPresetBankCapabilities","presetBankCapabilities","KEY_PRESET_BANK_CAPABILITIES","getPresetBankCapabilities","setHmiZoneCapabilities","hmiZoneCapabilities","KEY_HMI_ZONE_CAPABILITIES","getHmiZoneCapabilities","setSpeechCapabilities","speechCapabilities","KEY_SPEECH_CAPABILITIES","getSpeechCapabilities","setPrerecordedSpeech","KEY_PRERECORDED_SPEECH","getPrerecordedSpeech","setVrCapabilities","vrCapabilities","KEY_VR_CAPABILITIES","getVrCapabilities","setAudioPassThruCapabilities","audioPassThruCapabilities","KEY_AUDIO_PASS_THRU_CAPABILITIES","getAudioPassThruCapabilities","setPcmStreamCapabilities","pcmStreamCapabilities","KEY_PCM_STREAM_CAPABILITIES","getPcmStreamCapabilities","setVehicleType","vehicleType","KEY_VEHICLE_TYPE","getVehicleType","setSupportedDiagModes","supportedDiagModes","KEY_SUPPORTED_DIAG_MODE","getSupportedDiagModes","setHMICapabilities","hmiCapabilities","KEY_HMI_CAPABILITIES","getHMICapabilities","setSdlVersion","sdlVersion","KEY_SDL_VERSION","getSdlVersion","setSystemSoftwareVersion","systemSoftwareVersion","KEY_SYSTEM_SOFTWARE_VERSION","getSystemSoftwareVersion","setIconResumed","iconResumed","KEY_ICON_RESUMED","getIconResumed","SetAppIconResponse","SoftButtonType","SBT_TEXT","SBT_IMAGE","SBT_BOTH","SystemAction","DEFAULT_ACTION","STEAL_FOCUS","KEEP_CONTEXT","SoftButton","setImage","image","KEY_IMAGE","getImage","setIsHighlighted","isHighlighted","KEY_IS_HIGHLIGHTED","getIsHighlighted","setSoftButtonID","softButtonID","KEY_SOFT_BUTTON_ID","getSoftButtonID","setSystemAction","systemAction","KEY_SYSTEM_ACTION","getSystemAction","MetadataType","mediaTitle","mediaArtist","mediaAlbum","mediaYear","mediaGenre","mediaStation","rating","currentTemperature","maximumTemperature","minimumTemperature","weatherTerm","humidity","MetadataTags","setMainField1","KEY_MAIN_FIELD_1","getMainField1","setMainField2","KEY_MAIN_FIELD_2","getMainField2","setMainField3","KEY_MAIN_FIELD_3","getMainField3","setMainField4","KEY_MAIN_FIELD_4","getMainField4","TextAlignment","LEFT_ALIGNED","RIGHT_ALIGNED","CENTERED","setAlignment","alignment","KEY_ALIGNMENT","getAlignment","setStatusBar","KEY_STATUS_BAR","getStatusBar","setMediaClock","KEY_MEDIA_CLOCK","getMediaClock","setMediaTrack","KEY_MEDIA_TRACK","getMediaTrack","setGraphic","KEY_GRAPHIC","getGraphic","setSecondaryGraphic","KEY_SECONDARY_GRAPHIC","getSecondaryGraphic","setSoftButtons","softButtons","KEY_SOFT_BUTTONS","getSoftButtons","setCustomPresets","customPresets","KEY_CUSTOM_PRESETS","getCustomPresets","setMetadataTags","metadataTags","KEY_METADATA_TAGS","getMetadataTags","setTemplateTitle","KEY_TEMPLATE_TITLE","getTemplateTitle","ShowResponse","UnregisterAppInterfaceResponse","RpcCreator","construct","rpcName","jsonData","VideoStreamingProtocol","RAW","RTP","RTSP","RTMP","WEBM","VideoStreamingCodec","H264","H265","Theora","VP8","VP9","VideoStreamingFormat","setProtocol","KEY_PROTOCOL","getProtocol","setCodec","KEY_CODEC","getCodec","SdlProtocolBase","baseTransportConfig","sdlProtocolListener","_baseTransportConfig","_sdlProtocolListener","_transportManager","_reset","_createTransportListener","_protocolVersion","_headerSize","V1_HEADER_SIZE","_serviceStatus","_mtus","V1_V2_MTU_SIZE","_hashID","_messageFrameAssemblers","setTransportManager","manager","startService","_transportListener","_handleTransportConnected","_handlePacketReceived","protocolVersion","MAX_PROTOCOL_VERSION","sendPacket","videoStreamingParameters","desiredResolution","desiredFormat","getFormat","getMtu","retVal","isConnected","getProtocolVersion","_setVersion","V2_HEADER_SIZE","V3_V4_MTU_SIZE","_getNextMessageID","sendRpc","_handleControlPacket","messageFrameAssembler","_getMessageFrameAssembler","_handleOnMessageAssembled","_handleRPCPacket","_handleProtocolHeartbeat","_handleProtocolHeartbeatACK","_handleStartServiceACK","_handleStartServiceNAK","_handleEndServiceACK","_handleEndService","_handleEndServiceNAK","heartbeat","mtuTag","NAV","acceptedResolution","acceptedFormat","agreedVideoParams","setFormat","_handleServiceEnded","rejectedTag","rejectedParams","endService","TransportType","WEBSOCKET_CLIENT","WEBSOCKET_SERVER","CUSTOM","SdlPsm","reset","_state","START_STATE","_controlFrameInfo","_dumpSize","_dataLength","getState","getFormedPacket","FINISHED_STATE","handleByte","_transitionOnInput","ERROR_STATE","rawByte","state","VERSION_MASK","ENCRYPTION_MASK","FRAME_TYPE_MASK","SERVICE_TYPE_STATE","CONTROL_FRAME_INFO_STATE","SESSION_ID_STATE","DATA_SIZE_1_STATE","DATA_SIZE_2_STATE","DATA_SIZE_3_STATE","DATA_SIZE_4_STATE","DATA_PUMP_STATE","FIRST_FRAME_DATA_SIZE","MESSAGE_1_STATE","MESSAGE_2_STATE","MESSAGE_3_STATE","MESSAGE_4_STATE","TransportBase","transportCallback","_sdlPsm","_transportCallback","stop","setTransportCallback","WebSocketClient","config","_queue","_isRunning","_wsUrl","getHost","getPort","_ws","_init","WebSocket","onopen","onConnectionEstablished","onerror","onmessage","_handleIncoming","onclose","onConnectionTerminated","close","packet","send","_multiByteHandler","msgData","Response","arrayBuffer","then","_handleByte","isFinished","TransportCallback","_onConnectionEstablished","_onConnectionTerminated","setOnConnectionEstablished","setOnConnectionTerminated","TransportManagerBase","transportListener","_transport","_isConnected","getTransportType","getTransport","transportType","address","require$$1","WebSocketServer","_connectionLostInterval","client","getClient","connectionLostTimeout","getConnectionLostTimeout","on","_handleMessage","_stopConnectionLostInterval","errorEvent","isAlive","setInterval","terminate","ping","readyState","OPEN","clearInterval","stateProgress","messageIndex","require$$2","TransportManager","SdlProtocol","ServiceListenerMap","_listeners","addListener","serviceListener","removeListener","listenerArray","removed","sendEventServiceStarted","session","sendEventServiceEnded","sendEventServiceError","onServiceError","DEFAULT_PROTOCOL","DEFAULT_CODEC","DEFAULT_WIDTH","DEFAULT_HEIGHT","DEFAULT_DENSITY","DEFAULT_FRAMERATE","DEFAULT_BITRATE","DEFAULT_INTERVAL","DEFAULT_SCALE","VideoStreamingParameters","displayDensity","frameRate","bitrate","interval","_displayDensity","_frameRate","_bitrate","_interval","_resolution","_format","update","capability","getMaxBitrate","scale","getScale","getPreferredResolution","formats","getSupportedFormats","setDisplayDensity","getDisplayDensity","setFrameRate","getFrameRate","setBitrate","getBitrate","getInterval","SdlSession","sdlSessionListener","_sessionHashId","_sdlSessionListener","_serviceListeners","_setupSdlProtocolListener","_sdlProtocol","getCurrentTransportType","getIsConnected","getSessionHashId","addServiceListener","sdlServiceListener","removeServiceListener","getServiceListeners","setDesiredVideoParams","_desiredVideoParams","SdlSessionListener","correlationI","ArrayTools","arrayRemove","ele","LifecycleManager","appConfig","lifecycleListener","_appConfig","_lifecycleListener","_sdlSession","_createSessionListener","_currentHMIStatus","_firstTimeFull","_responseListeners","_maxCorrelationId","_rpcListeners","sessionListener","sendRpcMessage","_createRegisterAppInterface","_handleRpc","functionID","resolve","_setupInternalRpcListeners","addRpcListener","rpcListener","removeRpcListener","getRegisterAppInterfaceResponse","_registerAppInterfaceResponse","registerAppInterface","MAX_RPC_VERSION","REGISTER_APP_INTERFACE_CORRELATION_ID","_rpcListener","_processRaiResponse","shouldInit","registerAppInterfaceResponse","msgVersion","UNREGISTER_APP_INTERFACE_CORRELATION_ID","VideoStreamingCapability","setPreferredResolution","KEY_PREFERRED_RESOLUTION","setMaxBitrate","KEY_MAX_BITRATE","setSupportedFormats","KEY_SUPPORTED_FORMATS","setHapticSpatialDataSupported","KEY_HAPTIC_SPATIAL_DATA_SUPPORTED","getHapticSpatialDataSupported","setDiagonalScreenSize","KEY_DIAGONAL_SCREEN_SIZE","getDiagonalScreenSize","setPixelPerInch","KEY_PIXEL_PER_INCH","getPixelPerInch","setScale","KEY_SCALE","SdlServiceListener","_onServiceError","setOnServiceError","CustomTransport","onSendPacket","onByteBufferReceived","sdlPsm","TransportConfigBase","_transportType","CustomTransportConfig","customTransport","_customTransport","SslConfig","pemCertificate","privateKey","password","_pemCertificate","_privateKey","_password","getPemCertificate","getPrivateKey","getPassword","WebSocketClientConfig","host","port","_host","_port","TransportRecord","_address","getAddress","WebSocketServerConfig","_client","_connectionLostTimeout","SDL","lifecycle","protocol","enums","rpc","messages","structs","streaming","video","transport"],"mappings":"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d,KAAsB,gBAA7B;IACD,KAFD;;;IAKO,GAtyPG;;;;IAwyPH,YAASnC,MAAT,EAAiBL,OAAjB,EAA0B;IAEjCK,IAAAA,MAAM,CAACL,OAAP,GAAiBuuB,IAAjB;;;;;IAKA,QAAIiQ,IAAI,GAAG,IAAX;;IAEA,QAAI;IACFA,MAAAA,IAAI,GAAG,IAAIC,WAAW,CAACC,QAAhB,CAAyB,IAAID,WAAW,CAACE,MAAhB,CAAuB,IAAIl8B,UAAJ,CAAe,CACpE,CADoE,EACjE,EADiE,EAC7D,GAD6D,EACxD,GADwD,EACnD,CADmD,EAChD,CADgD,EAC7C,CAD6C,EAC1C,CAD0C,EACvC,CADuC,EACpC,EADoC,EAChC,CADgC,EAC7B,EAD6B,EACzB,CADyB,EACtB,CADsB,EACnB,GADmB,EACd,EADc,EACV,CADU,EACP,GADO,EACF,GADE,EACG,GADH,EACQ,GADR,EACa,CADb,EACgB,GADhB,EACqB,CADrB,EACwB,CADxB,EAC2B,CAD3B,EAC8B,CAD9B,EACiC,CADjC,EACoC,CADpC,EACuC,CADvC,EAC0C,CAD1C,EAC6C,CAD7C,EACgD,CADhD,EACmD,CADnD,EACsD,CADtD,EACyD,GADzD,EAC8D,CAD9D,EACiE,EADjE,EACqE,CADrE,EACwE,EADxE,EAC4E,CAD5E,EAC+E,EAD/E,EACmF,CADnF,EACsF,CADtF,EACyF,GADzF,EAC8F,GAD9F,EACmG,GADnG,EACwG,CADxG,EAC2G,CAD3G,EAC8G,CAD9G,EACiH,GADjH,EACsH,GADtH,EAC2H,GAD3H,EACgI,EADhI,EACoI,GADpI,EACyI,CADzI,EAC4I,CAD5I,EAC+I,CAD/I,EACkJ,GADlJ,EACuJ,GADvJ,EAC4J,GAD5J,EACiK,EADjK,EACqK,GADrK,EAC0K,CAD1K,EAC6K,CAD7K,EACgL,CADhL,EACmL,GADnL,EACwL,GADxL,EAC6L,GAD7L,EACkM,EADlM,EACsM,GADtM,EAC2M,CAD3M,EAC8M,CAD9M,EACiN,CADjN,EACoN,GADpN,EACyN,GADzN,EAC8N,GAD9N,EACmO,EADnO,EACuO,GADvO,EAC4O,CAD5O,EAC+O,CAD/O,EACkP,CADlP,EACqP,GADrP,EAC0P,GAD1P,EAC+P,GAD/P,EACoQ,EADpQ,EACwQ,GADxQ,EAC6Q,GAD7Q,EACkR,GADlR,EACuR,GADvR,EAC4R,CAD5R,EAC+R,CAD/R,EACkS,EADlS,EACsS,GADtS,EAC2S,CAD3S,EAC8S,CAD9S,EACiT,CADjT,EACoT,CADpT,EACuT,EADvT,EAC2T,CAD3T,EAC8T,EAD9T,EACkU,EADlU,EACsU,CADtU,EACyU,CADzU,EAC4U,GAD5U,EACiV,EADjV,EACqV,CADrV,EACwV,GADxV,EAC6V,EAD7V,EACiW,CADjW,EACoW,GADpW,EACyW,EADzW,EAC6W,EAD7W,EACiX,GADjX,EACsX,GADtX,EAC2X,EAD3X,EAC+X,CAD/X,EACkY,GADlY,EACuY,EADvY,EAC2Y,CAD3Y,EAC8Y,GAD9Y,EACmZ,EADnZ,EACuZ,EADvZ,EAC2Z,GAD3Z,EACga,GADha,EACqa,GADra,EAC0a,EAD1a,EAC8a,CAD9a,EACib,EADjb,EACqb,EADrb,EACyb,GADzb,EAC8b,GAD9b,EACmc,EADnc,EACuc,CADvc,EAC0c,EAD1c,EAC8c,CAD9c,EACid,GADjd,EACsd,EADtd,EAC0d,EAD1d,EAC8d,CAD9d,EACie,CADje,EACoe,GADpe,EACye,EADze,EAC6e,CAD7e,EACgf,GADhf,EACqf,EADrf,EACyf,CADzf,EAC4f,GAD5f,EACigB,EADjgB,EACqgB,EADrgB,EACygB,GADzgB,EAC8gB,GAD9gB,EACmhB,EADnhB,EACuhB,CADvhB,EAC0hB,GAD1hB,EAC+hB,EAD/hB,EACmiB,CADniB,EACsiB,GADtiB,EAC2iB,EAD3iB,EAC+iB,EAD/iB,EACmjB,GADnjB,EACwjB,GADxjB,EAC6jB,GAD7jB,EACkkB,EADlkB,EACskB,CADtkB,EACykB,EADzkB,EAC6kB,EAD7kB,EACilB,GADjlB,EACslB,GADtlB,EAC2lB,EAD3lB,EAC+lB,CAD/lB,EACkmB,EADlmB,EACsmB,CADtmB,EACymB,GADzmB,EAC8mB,EAD9mB,EACknB,EADlnB,EACsnB,CADtnB,EACynB,CADznB,EAC4nB,GAD5nB,EACioB,EADjoB,EACqoB,CADroB,EACwoB,GADxoB,EAC6oB,EAD7oB,EACipB,CADjpB,EACopB,GADppB,EACypB,EADzpB,EAC6pB,EAD7pB,EACiqB,GADjqB,EACsqB,GADtqB,EAC2qB,EAD3qB,EAC+qB,CAD/qB,EACkrB,GADlrB,EACurB,EADvrB,EAC2rB,CAD3rB,EAC8rB,GAD9rB,EACmsB,EADnsB,EACusB,EADvsB,EAC2sB,GAD3sB,EACgtB,GADhtB,EACqtB,GADrtB,EAC0tB,EAD1tB,EAC8tB,CAD9tB,EACiuB,EADjuB,EACquB,EADruB,EACyuB,GADzuB,EAC8uB,GAD9uB,EACmvB,EADnvB,EACuvB,CADvvB,EAC0vB,EAD1vB,EAC8vB,CAD9vB,EACiwB,GADjwB,EACswB,EADtwB,EAC0wB,EAD1wB,EAC8wB,CAD9wB,EACixB,CADjxB,EACoxB,GADpxB,EACyxB,EADzxB,EAC6xB,CAD7xB,EACgyB,GADhyB,EACqyB,EADryB,EACyyB,CADzyB,EAC4yB,GAD5yB,EACizB,EADjzB,EACqzB,EADrzB,EACyzB,GADzzB,EAC8zB,GAD9zB,EACm0B,EADn0B,EACu0B,CADv0B,EAC00B,GAD10B,EAC+0B,EAD/0B,EACm1B,CADn1B,EACs1B,GADt1B,EAC21B,EAD31B,EAC+1B,EAD/1B,EACm2B,GADn2B,EACw2B,GADx2B,EAC62B,GAD72B,EACk3B,EADl3B,EACs3B,CADt3B,EACy3B,EADz3B,EAC63B,EAD73B,EACi4B,GADj4B,EACs4B,GADt4B,EAC24B,EAD34B,EAC+4B,CAD/4B,EACk5B,EADl5B,EACs5B,CADt5B,EACy5B,GADz5B,EAC85B,EAD95B,EACk6B,EADl6B,EACs6B,CADt6B,EACy6B,CADz6B,EAC46B,GAD56B,EACi7B,EADj7B,EACq7B,CADr7B,EACw7B,GADx7B,EAC67B,EAD77B,EACi8B,CADj8B,EACo8B,GADp8B,EACy8B,EADz8B,EAC68B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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","sources":["../tmp/manager/AppConfig.js","../tmp/manager/lifecycle/LifecycleListener.js","../tmp/util/Enum.js","../tmp/rpc/RpcStruct.js","../tmp/rpc/structs/AppInfo.js","../tmp/rpc/structs/RGBColor.js","../tmp/rpc/structs/TemplateColorScheme.js","../tmp/rpc/enums/FunctionID.js","../tmp/rpc/enums/SpeechCapabilities.js","../tmp/rpc/structs/TTSChunk.js","../tmp/rpc/structs/SdlMsgVersion.js","../tmp/rpc/enums/AppHMIType.js","../tmp/rpc/enums/Language.js","../tmp/rpc/RpcMessage.js","../tmp/rpc/enums/RpcType.js","../tmp/rpc/RpcRequest.js","../tmp/rpc/structs/DeviceInfo.js","../tmp/rpc/messages/RegisterAppInterface.js","../tmp/rpc/enums/Result.js","../tmp/rpc/RpcResponse.js","../tmp/rpc/RpcListener.js","../tmp/protocol/SdlProtocolListener.js","../tmp/protocol/enums/FrameType.js","../../../third_party/bson.common.js","../tmp/util/Bson.js","../tmp/protocol/SdlPacket.js","../../../node_modules/rollup-plugin-node-globals/src/global.js","../../../node_modules/buffer-es6/base64.js","../../../node_modules/buffer-es6/ieee754.js","../../../node_modules/buffer-es6/isArray.js","../../../node_modules/buffer-es6/index.js","../tmp/util/TextEncoder.js","../tmp/util/JsonRpcMarshaller.js","../tmp/protocol/BinaryFrameHeader.js","../tmp/protocol/MessageFrameDisassembler.js","../tmp/transport/TransportListener.js","../tmp/util/Version.js","../tmp/protocol/enums/ServiceType.js","../tmp/protocol/MessageFrameAssembler.js","../tmp/protocol/enums/ControlFrameTags.js","../tmp/util/BitConverter.js","../tmp/protocol/SdlPacketFactory.js","../tmp/rpc/structs/SoftButtonCapabilities.js","../tmp/rpc/enums/PrerecordedSpeech.js","../tmp/rpc/structs/PresetBankCapabilities.js","../tmp/rpc/structs/VehicleType.js","../tmp/rpc/enums/HmiZoneCapabilities.js","../tmp/rpc/enums/MediaClockFormat.js","../tmp/rpc/structs/ImageResolution.js","../tmp/rpc/structs/TouchEventCapabilities.js","../tmp/rpc/structs/ScreenParams.js","../tmp/rpc/enums/ImageFieldName.js","../tmp/rpc/enums/FileType.js","../tmp/rpc/structs/ImageField.js","../tmp/rpc/enums/DisplayType.js","../tmp/rpc/enums/TextFieldName.js","../tmp/rpc/enums/CharacterSet.js","../tmp/rpc/structs/TextField.js","../tmp/rpc/structs/DisplayCapabilities.js","../tmp/rpc/enums/SamplingRate.js","../tmp/rpc/enums/BitsPerSample.js","../tmp/rpc/enums/AudioType.js","../tmp/rpc/structs/AudioPassThruCapabilities.js","../tmp/rpc/enums/VrCapabilities.js","../tmp/rpc/enums/ButtonName.js","../tmp/rpc/structs/Grid.js","../tmp/rpc/structs/ModuleInfo.js","../tmp/rpc/structs/ButtonCapabilities.js","../tmp/rpc/structs/HMICapabilities.js","../tmp/rpc/messages/RegisterAppInterfaceResponse.js","../tmp/rpc/messages/UnregisterAppInterface.js","../tmp/rpc/messages/UnregisterAppInterfaceResponse.js","../tmp/rpc/enums/WindowType.js","../tmp/rpc/messages/CreateWindow.js","../tmp/rpc/messages/CreateWindowResponse.js","../tmp/rpc/messages/DeleteWindow.js","../tmp/rpc/messages/DeleteWindowResponse.js","../tmp/rpc/enums/ImageType.js","../tmp/rpc/structs/Image.js","../tmp/rpc/structs/VrHelpItem.js","../tmp/rpc/structs/SeatLocation.js","../tmp/rpc/enums/MenuLayout.js","../tmp/rpc/enums/KeyboardLayout.js","../tmp/rpc/enums/KeypressMode.js","../tmp/rpc/structs/KeyboardProperties.js","../tmp/rpc/messages/SetGlobalProperties.js","../tmp/rpc/messages/SetGlobalPropertiesResponse.js","../tmp/rpc/enums/GlobalProperty.js","../tmp/rpc/messages/ResetGlobalProperties.js","../tmp/rpc/messages/ResetGlobalPropertiesResponse.js","../tmp/rpc/structs/MenuParams.js","../tmp/rpc/messages/AddCommand.js","../tmp/rpc/messages/AddCommandResponse.js","../tmp/rpc/messages/DeleteCommand.js","../tmp/rpc/messages/DeleteCommandResponse.js","../tmp/rpc/messages/AddSubMenu.js","../tmp/rpc/messages/AddSubMenuResponse.js","../tmp/rpc/messages/DeleteSubMenu.js","../tmp/rpc/messages/DeleteSubMenuResponse.js","../tmp/rpc/messages/ShowAppMenu.js","../tmp/rpc/messages/ShowAppMenuResponse.js","../tmp/rpc/structs/Choice.js","../tmp/rpc/messages/CreateInteractionChoiceSet.js","../tmp/rpc/messages/CreateInteractionChoiceSetResponse.js","../tmp/rpc/enums/LayoutMode.js","../tmp/rpc/enums/InteractionMode.js","../tmp/rpc/messages/PerformInteraction.js","../tmp/rpc/enums/TriggerSource.js","../tmp/rpc/messages/PerformInteractionResponse.js","../tmp/rpc/messages/DeleteInteractionChoiceSet.js","../tmp/rpc/messages/DeleteInteractionChoiceSetResponse.js","../tmp/rpc/enums/SoftButtonType.js","../tmp/rpc/enums/SystemAction.js","../tmp/rpc/structs/SoftButton.js","../tmp/rpc/messages/Alert.js","../tmp/rpc/messages/AlertResponse.js","../tmp/rpc/enums/TextAlignment.js","../tmp/rpc/structs/TemplateConfiguration.js","../tmp/rpc/enums/MetadataType.js","../tmp/rpc/structs/MetadataTags.js","../tmp/rpc/messages/Show.js","../tmp/rpc/messages/ShowResponse.js","../tmp/rpc/messages/Speak.js","../tmp/rpc/messages/SpeakResponse.js","../tmp/rpc/structs/StartTime.js","../tmp/rpc/enums/UpdateMode.js","../tmp/rpc/enums/AudioStreamingIndicator.js","../tmp/rpc/messages/SetMediaClockTimer.js","../tmp/rpc/messages/SetMediaClockTimerResponse.js","../tmp/rpc/messages/PerformAudioPassThru.js","../tmp/rpc/messages/PerformAudioPassThruResponse.js","../tmp/rpc/messages/EndAudioPassThru.js","../tmp/rpc/messages/EndAudioPassThruResponse.js","../tmp/rpc/messages/SubscribeButton.js","../tmp/rpc/messages/SubscribeButtonResponse.js","../tmp/rpc/messages/UnsubscribeButton.js","../tmp/rpc/messages/UnsubscribeButtonResponse.js","../tmp/rpc/messages/SubscribeVehicleData.js","../tmp/rpc/enums/VehicleDataResultCode.js","../tmp/rpc/enums/VehicleDataType.js","../tmp/rpc/structs/VehicleDataResult.js","../tmp/rpc/messages/SubscribeVehicleDataResponse.js","../tmp/rpc/messages/UnsubscribeVehicleData.js","../tmp/rpc/messages/UnsubscribeVehicleDataResponse.js","../tmp/rpc/messages/GetVehicleData.js","../tmp/rpc/enums/VehicleDataEventStatus.js","../tmp/rpc/structs/AirbagStatus.js","../tmp/rpc/enums/PowerModeStatus.js","../tmp/rpc/enums/CarModeStatus.js","../tmp/rpc/enums/PowerModeQualificationStatus.js","../tmp/rpc/structs/ClusterModeStatus.js","../tmp/rpc/enums/FuelCutoffStatus.js","../tmp/rpc/enums/EmergencyEventType.js","../tmp/rpc/structs/EmergencyEvent.js","../tmp/rpc/enums/TurnSignal.js","../tmp/rpc/enums/AmbientLightStatus.js","../tmp/rpc/structs/HeadLampStatus.js","../tmp/rpc/enums/PrimaryAudioSource.js","../tmp/rpc/enums/DeviceLevelStatus.js","../tmp/rpc/structs/DeviceStatus.js","../tmp/rpc/enums/WiperStatus.js","../tmp/rpc/enums/ElectronicParkBrakeStatus.js","../tmp/rpc/enums/VehicleDataStatus.js","../tmp/rpc/structs/MyKey.js","../tmp/rpc/enums/CompassDirection.js","../tmp/rpc/enums/Dimension.js","../tmp/rpc/structs/GPSData.js","../tmp/rpc/enums/PRNDL.js","../tmp/rpc/enums/FuelType.js","../tmp/rpc/structs/FuelRange.js","../tmp/rpc/enums/VehicleDataNotificationStatus.js","../tmp/rpc/enums/ECallConfirmationStatus.js","../tmp/rpc/structs/ECallInfo.js","../tmp/rpc/structs/BeltStatus.js","../tmp/rpc/enums/ComponentVolumeStatus.js","../tmp/rpc/enums/IgnitionStatus.js","../tmp/rpc/enums/IgnitionStableStatus.js","../tmp/rpc/structs/BodyInformation.js","../tmp/rpc/enums/TPMS.js","../tmp/rpc/structs/SingleTireStatus.js","../tmp/rpc/enums/WarningLightStatus.js","../tmp/rpc/structs/TireStatus.js","../tmp/rpc/messages/GetVehicleDataResponse.js","../tmp/rpc/messages/ReadDID.js","../tmp/rpc/structs/DIDResult.js","../tmp/rpc/messages/ReadDIDResponse.js","../tmp/rpc/messages/GetDTCs.js","../tmp/rpc/messages/GetDTCsResponse.js","../tmp/rpc/messages/DiagnosticMessage.js","../tmp/rpc/messages/DiagnosticMessageResponse.js","../tmp/rpc/messages/ScrollableMessage.js","../tmp/rpc/messages/ScrollableMessageResponse.js","../tmp/rpc/messages/Slider.js","../tmp/rpc/messages/SliderResponse.js","../tmp/rpc/messages/ShowConstantTBT.js","../tmp/rpc/messages/ShowConstantTBTResponse.js","../tmp/rpc/messages/AlertManeuver.js","../tmp/rpc/messages/AlertManeuverResponse.js","../tmp/rpc/structs/Turn.js","../tmp/rpc/messages/UpdateTurnList.js","../tmp/rpc/messages/UpdateTurnListResponse.js","../tmp/rpc/messages/ChangeRegistration.js","../tmp/rpc/messages/ChangeRegistrationResponse.js","../tmp/rpc/messages/GenericResponseResponse.js","../tmp/rpc/messages/PutFile.js","../tmp/rpc/messages/PutFileResponse.js","../tmp/rpc/messages/GetFile.js","../tmp/rpc/messages/GetFileResponse.js","../tmp/rpc/messages/DeleteFile.js","../tmp/rpc/messages/DeleteFileResponse.js","../tmp/rpc/messages/ListFiles.js","../tmp/rpc/messages/ListFilesResponse.js","../tmp/rpc/messages/SetAppIcon.js","../tmp/rpc/messages/SetAppIconResponse.js","../tmp/rpc/messages/SetDisplayLayout.js","../tmp/rpc/messages/SetDisplayLayoutResponse.js","../tmp/rpc/enums/RequestType.js","../tmp/rpc/messages/SystemRequest.js","../tmp/rpc/messages/SystemRequestResponse.js","../tmp/rpc/enums/DeliveryMode.js","../tmp/rpc/structs/DateTime.js","../tmp/rpc/structs/OASISAddress.js","../tmp/rpc/messages/SendLocation.js","../tmp/rpc/messages/SendLocationResponse.js","../tmp/rpc/messages/DialNumber.js","../tmp/rpc/messages/DialNumberResponse.js","../tmp/rpc/enums/ButtonPressMode.js","../tmp/rpc/enums/ModuleType.js","../tmp/rpc/messages/ButtonPress.js","../tmp/rpc/messages/ButtonPressResponse.js","../tmp/rpc/messages/GetInteriorVehicleData.js","../tmp/rpc/enums/DisplayMode.js","../tmp/rpc/enums/DistanceUnit.js","../tmp/rpc/enums/TemperatureUnit.js","../tmp/rpc/structs/HMISettingsControlData.js","../tmp/rpc/enums/RadioBand.js","../tmp/rpc/structs/RdsData.js","../tmp/rpc/enums/RadioState.js","../tmp/rpc/structs/StationIDNumber.js","../tmp/rpc/structs/SisData.js","../tmp/rpc/structs/RadioControlData.js","../tmp/rpc/structs/Temperature.js","../tmp/rpc/enums/VentilationMode.js","../tmp/rpc/enums/DefrostZone.js","../tmp/rpc/structs/ClimateControlData.js","../tmp/rpc/structs/EqualizerSettings.js","../tmp/rpc/structs/AudioControlData.js","../tmp/rpc/enums/MassageCushion.js","../tmp/rpc/structs/MassageCushionFirmness.js","../tmp/rpc/enums/SupportedSeat.js","../tmp/rpc/enums/SeatMemoryActionType.js","../tmp/rpc/structs/SeatMemoryAction.js","../tmp/rpc/enums/MassageZone.js","../tmp/rpc/enums/MassageMode.js","../tmp/rpc/structs/MassageModeData.js","../tmp/rpc/structs/SeatControlData.js","../tmp/rpc/enums/LightStatus.js","../tmp/rpc/enums/LightName.js","../tmp/rpc/structs/LightState.js","../tmp/rpc/structs/LightControlData.js","../tmp/rpc/structs/ModuleData.js","../tmp/rpc/messages/GetInteriorVehicleDataResponse.js","../tmp/rpc/messages/GetInteriorVehicleDataConsent.js","../tmp/rpc/messages/GetInteriorVehicleDataConsentResponse.js","../tmp/rpc/messages/ReleaseInteriorVehicleDataModule.js","../tmp/rpc/messages/ReleaseInteriorVehicleDataModuleResponse.js","../tmp/rpc/messages/SetInteriorVehicleData.js","../tmp/rpc/messages/SetInteriorVehicleDataResponse.js","../tmp/rpc/messages/SubscribeWayPoints.js","../tmp/rpc/messages/SubscribeWayPointsResponse.js","../tmp/rpc/enums/WayPointType.js","../tmp/rpc/messages/GetWayPoints.js","../tmp/rpc/structs/Coordinate.js","../tmp/rpc/structs/LocationDetails.js","../tmp/rpc/messages/GetWayPointsResponse.js","../tmp/rpc/messages/UnsubscribeWayPoints.js","../tmp/rpc/messages/UnsubscribeWayPointsResponse.js","../tmp/rpc/enums/SystemCapabilityType.js","../tmp/rpc/messages/GetSystemCapability.js","../tmp/rpc/enums/VideoStreamingCodec.js","../tmp/rpc/enums/VideoStreamingProtocol.js","../tmp/rpc/structs/VideoStreamingFormat.js","../tmp/rpc/structs/VideoStreamingCapability.js","../tmp/rpc/structs/PhoneCapability.js","../tmp/rpc/structs/WindowTypeCapabilities.js","../tmp/rpc/structs/WindowCapability.js","../tmp/rpc/structs/DisplayCapability.js","../tmp/rpc/structs/AudioControlCapabilities.js","../tmp/rpc/structs/LightCapabilities.js","../tmp/rpc/structs/LightControlCapabilities.js","../tmp/rpc/structs/ClimateControlCapabilities.js","../tmp/rpc/structs/SeatControlCapabilities.js","../tmp/rpc/structs/RadioControlCapabilities.js","../tmp/rpc/structs/HMISettingsControlCapabilities.js","../tmp/rpc/structs/RemoteControlCapabilities.js","../tmp/rpc/structs/SeatLocationCapability.js","../tmp/rpc/enums/ServiceUpdateReason.js","../tmp/rpc/structs/NavigationServiceManifest.js","../tmp/rpc/structs/WeatherServiceManifest.js","../tmp/rpc/structs/MediaServiceManifest.js","../tmp/rpc/structs/AppServiceManifest.js","../tmp/rpc/structs/AppServiceRecord.js","../tmp/rpc/structs/AppServiceCapability.js","../tmp/rpc/structs/AppServicesCapabilities.js","../tmp/rpc/structs/NavigationCapability.js","../tmp/rpc/structs/SystemCapability.js","../tmp/rpc/messages/GetSystemCapabilityResponse.js","../tmp/rpc/structs/Rectangle.js","../tmp/rpc/structs/HapticRect.js","../tmp/rpc/messages/SendHapticData.js","../tmp/rpc/messages/SendHapticDataResponse.js","../tmp/rpc/enums/HybridAppPreference.js","../tmp/rpc/structs/CloudAppProperties.js","../tmp/rpc/messages/SetCloudAppProperties.js","../tmp/rpc/messages/SetCloudAppPropertiesResponse.js","../tmp/rpc/messages/GetCloudAppProperties.js","../tmp/rpc/messages/GetCloudAppPropertiesResponse.js","../tmp/rpc/messages/PublishAppService.js","../tmp/rpc/messages/PublishAppServiceResponse.js","../tmp/rpc/messages/UnpublishAppService.js","../tmp/rpc/messages/UnpublishAppServiceResponse.js","../tmp/rpc/messages/GetAppServiceData.js","../tmp/rpc/enums/NavigationJunction.js","../tmp/rpc/enums/Direction.js","../tmp/rpc/enums/NavigationAction.js","../tmp/rpc/structs/NavigationInstruction.js","../tmp/rpc/structs/NavigationServiceData.js","../tmp/rpc/enums/MediaType.js","../tmp/rpc/structs/MediaServiceData.js","../tmp/rpc/structs/WeatherData.js","../tmp/rpc/structs/WeatherAlert.js","../tmp/rpc/structs/WeatherServiceData.js","../tmp/rpc/structs/AppServiceData.js","../tmp/rpc/messages/GetAppServiceDataResponse.js","../tmp/rpc/messages/PerformAppServiceInteraction.js","../tmp/rpc/messages/PerformAppServiceInteractionResponse.js","../tmp/rpc/messages/CancelInteraction.js","../tmp/rpc/messages/CancelInteractionResponse.js","../tmp/rpc/messages/CloseApplication.js","../tmp/rpc/messages/CloseApplicationResponse.js","../tmp/rpc/enums/SystemContext.js","../tmp/rpc/RpcNotification.js","../tmp/rpc/enums/AudioStreamingState.js","../tmp/rpc/enums/HMILevel.js","../tmp/rpc/enums/VideoStreamingState.js","../tmp/rpc/messages/OnHMIStatus.js","../tmp/rpc/enums/AppInterfaceUnregisteredReason.js","../tmp/rpc/messages/OnAppInterfaceUnregistered.js","../tmp/rpc/enums/ButtonEventMode.js","../tmp/rpc/messages/OnButtonEvent.js","../tmp/rpc/messages/OnButtonPress.js","../tmp/rpc/messages/OnVehicleData.js","../tmp/rpc/messages/OnCommand.js","../tmp/rpc/enums/TBTState.js","../tmp/rpc/messages/OnTBTClientState.js","../tmp/rpc/enums/DriverDistractionState.js","../tmp/rpc/messages/OnDriverDistraction.js","../tmp/rpc/structs/HMIPermissions.js","../tmp/rpc/structs/ParameterPermissions.js","../tmp/rpc/structs/PermissionItem.js","../tmp/rpc/messages/OnPermissionsChange.js","../tmp/rpc/messages/OnAudioPassThru.js","../tmp/rpc/messages/OnLanguageChange.js","../tmp/rpc/enums/KeyboardEvent.js","../tmp/rpc/messages/OnKeyboardInput.js","../tmp/rpc/structs/TouchCoord.js","../tmp/rpc/structs/TouchEvent.js","../tmp/rpc/enums/TouchType.js","../tmp/rpc/messages/OnTouchEvent.js","../tmp/rpc/messages/OnSystemRequest.js","../tmp/rpc/messages/OnHashChange.js","../tmp/rpc/messages/OnWayPointChange.js","../tmp/rpc/messages/OnInteriorVehicleData.js","../tmp/rpc/messages/OnRCStatus.js","../tmp/rpc/messages/OnAppServiceData.js","../tmp/rpc/messages/OnSystemCapabilityUpdated.js","../tmp/rpc/messages/EncodedSyncPData.js","../tmp/rpc/messages/EncodedSyncPDataResponse.js","../tmp/rpc/messages/OnEncodedSyncPData.js","../tmp/rpc/RpcCreator.js","../tmp/protocol/SdlProtocolBase.js","../tmp/transport/enums/TransportType.js","../tmp/transport/SdlPsm.js","../tmp/transport/TransportBase.js","../tmp/transport/WebSocketClient.js","../tmp/transport/TransportCallback.js","../tmp/transport/TransportManagerBase.js","../tmp/transport/WebSocketServer.js","../tmp/transport/TransportManager.js","../tmp/protocol/SdlProtocol.js","../tmp/session/ServiceListenerMap.js","../tmp/streaming/video/VideoStreamingParameters.js","../tmp/session/SdlSession.js","../tmp/session/SdlSessionListener.js","../tmp/util/ArrayTools.js","../tmp/manager/lifecycle/LifecycleManager.js","../tmp/rpc/enums/AppServiceType.js","../tmp/rpc/enums/MaintenanceModeStatus.js","../tmp/rpc/enums/PermissionStatus.js","../tmp/rpc/enums/PredefinedLayout.js","../tmp/rpc/enums/PredefinedWindows.js","../tmp/rpc/enums/TimerMode.js","../tmp/rpc/enums/VehicleDataActiveStatus.js","../tmp/rpc/enums/messageType.js","../tmp/session/SdlServiceListener.js","../tmp/transport/CustomTransport.js","../tmp/transport/TransportConfigBase.js","../tmp/transport/CustomTransportConfig.js","../tmp/transport/SslConfig.js","../tmp/transport/WebSocketClientConfig.js","../tmp/transport/util/TransportRecord.js","../tmp/transport/WebSocketServerConfig.js","../index.js"],"sourcesContent":["/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n// TODO This class may or may not be included in the release. We should determine if\n// there is a better coding pattern for this for javascript.\n\nclass AppConfig {\n    /**\n    * @constructor\n    */\n    constructor () {\n        this._transportConfig = null;\n        this._appId = null;\n        this._appName = null;\n        this._iconName = null;\n        this._iconFile = null;\n        this._shortAppName = null;\n        this._ttsName = null;\n        this._vrSynonyms = null;\n        this._isMediaApp = null;\n        this._languageDesired = null;\n        this._hmiDisplayLanguageDesired = null;\n        this._appTypes = null;\n        this._dayColorScheme = null;\n        this._nightColorScheme = null;\n        this._minimumRPCVersion = null;\n        this._minimumProtocolVersion = null;\n    }\n\n    /**\n    * @param {TransportConfigBase} transportConfig\n    * @return {AppConfig}\n    */\n    setTransportConfig (transportConfig) {\n        this._transportConfig = transportConfig;\n        return this;\n    }\n\n    /**\n    * @return {TransportConfigBase}\n    */\n    getTransportConfig () {\n        return this._transportConfig;\n    }\n\n    /**\n    * @param {String} appId\n    * @return {AppConfig}\n    */\n    setAppId (appId) {\n        this._appId = appId;\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppId () {\n        return this._appId;\n    }\n\n    /**\n    * @param {String} appName\n    * @return {AppConfig}\n    */\n    setAppName (appName) {\n        this._appName = appName;\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppName () {\n        return this._appName;\n    }\n\n    /**\n    * @param {String} iconName\n    * @param {Uint8Array} fileData\n    * @return {AppConfig}\n    */\n    setAppIcon (iconName = 'icon.png', fileData) {\n        // TODO create SdlArtwork\n        this._iconName = iconName;\n        this._iconFile = fileData;\n\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getAppIconName () {\n        return this._iconName;\n    }\n\n    /**\n    * @return {Uint8Array}\n    */\n    getAppIconFileData () {\n        return this._iconFile;\n    }\n\n    /**\n    * @param {String} shortAppName\n    * @return {AppConfig}\n    */\n    setShortAppName (shortAppName) {\n        this._shortAppName = shortAppName;\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getShortAppName () {\n        return this._shortAppName;\n    }\n\n    /**\n    * @param {Array<TTSChunk>} ttsName\n    * @return {AppConfig}\n    */\n    setTtsName (ttsName) {\n        this._ttsName = ttsName;\n        return this;\n    }\n\n    /**\n    * @return {Array<TTSChunk>}\n    */\n    getTtsName () {\n        return this._ttsName;\n    }\n\n    /**\n    * @param {Array<String>} vrSynonyms\n    * @return {AppConfig}\n    */\n    setVrSynonyms (vrSynonyms) {\n        this._vrSynonyms = vrSynonyms;\n        return this;\n    }\n\n    /**\n    * @return {Array<String>}\n    */\n    getVrSynonyms () {\n        return this._vrSynonyms;\n    }\n\n    /**\n    * @param {Boolean} isMediaApp\n    * @return {AppConfig}\n    */\n    setIsMediaApp (isMediaApp) {\n        this._isMediaApp = isMediaApp;\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    isMediaApp () {\n        return this._isMediaApp;\n    }\n\n    /**\n    * @param {Language} languageDesired\n    * @return {AppConfig}\n    */\n    setLanguageDesired (languageDesired) {\n        this._languageDesired = languageDesired;\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getLanguageDesired () {\n        return this._languageDesired;\n    }\n\n    /**\n    * @param {Language} hmiDisplayLanguageDesired\n    * @return {AppConfig}\n    */\n    setHmiDisplayLanguageDesired (hmiDisplayLanguageDesired) {\n        this._hmiDisplayLanguageDesired = hmiDisplayLanguageDesired;\n        return this;\n    }\n\n    /**\n    * @return {Language}\n    */\n    getHmiDisplayLanguageDesired () {\n        return this._hmiDisplayLanguageDesired;\n    }\n\n    /**\n    * @param {Array<AppHMIType>} appTypes an array of ordered app types\n    * @return {AppConfig}\n    */\n    setAppTypes (appTypes) {\n        this._appTypes = appTypes;\n        return this;\n    }\n\n    /**\n    * @return {Array<AppHMIType>}\n    */\n    getAppTypes () {\n        return this._appTypes;\n    }\n\n\n    /**\n    * @param {TemplateColorScheme} dayColorScheme\n    * @return {AppConfig}\n    */\n    setDayColorScheme (dayColorScheme) {\n        this._dayColorScheme = dayColorScheme;\n        return this;\n    }\n\n    /**\n    * @return {TemplateColorScheme}\n    */\n    getDayColorScheme () {\n        return this._dayColorScheme;\n    }\n\n    /**\n    * @param {TemplateColorScheme} nightColorScheme\n    * @return {AppConfig}\n    */\n    setNightColorScheme (nightColorScheme) {\n        this._nightColorScheme = nightColorScheme;\n        return this;\n    }\n\n    /**\n    * @return {TemplateColorScheme}\n    */\n    getNightColorScheme () {\n        return this._nightColorScheme;\n    }\n\n    /**\n    * The minimum RPC version that will be permitted to connect.\n    * If the RPC version of the head unit connected is below this version, an UnregisterAppInterface will be sent.\n    *\n    * @param {Version} minimumRPCVersion\n    * @return {AppConfig}\n    */\n    setMinimumRPCVersion (minimumRPCVersion) {\n        this._minimumRPCVersion = minimumRPCVersion;\n        return this;\n    }\n\n    /**\n     *\n    * @return {Version}\n    */\n    getMinimumRPCVersion () {\n        return this._minimumRPCVersion;\n    }\n\n\n    /**\n    * Sets the minimum protocol version that will be permitted to connect.\n    * If the protocol version of the head unit connected is below this version,\n    * the app will disconnect with an EndService protocol message and will not register.\n    * @param {Version} minimumProtocolVersion\n    * @return {AppConfig}\n    */\n    setMinimumProtocolVersion (minimumProtocolVersion) {\n        this._minimumProtocolVersion = minimumProtocolVersion;\n        return this;\n    }\n\n    /**\n    * @return {Version}\n    */\n    getMinimumProtocolVersion () {\n        return this._minimumProtocolVersion;\n    }\n}\n\nexport { AppConfig };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} LifecycleListener\n */\nclass LifecycleListener {\n    /**\n\t * @constructor\n\t */\n    constructor () {\n        this._onProxyConnected = null;\n        this._onProxyClosed = null;\n        this._onServiceStarted = null;\n        this._onServiceEnded = null;\n        this._onError = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProxyConnected (listener) {\n        this._onProxyConnected = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProxyClosed (listener) {\n        this._onProxyClosed = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceStarted (listener) {\n        this._onServiceStarted = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceEnded (listener) {\n        this._onServiceEnded = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnError (listener) {\n        this._onError = listener;\n    }\n\n    /**\n     * @param {LifecycleManager} lifecycleManager\n\n     */\n    onProxyConnected (lifecycleManager) {\n        if (typeof this._onProxyConnected === 'function') {\n            this._onProxyConnected(lifecycleManager);\n        }\n    }\n\n    /**\n     * @param {LifecycleManager} lifecycleManager\n     * @param {String} info\n     * @param {SdlDisconnectedReason} reason\n     */\n    onProxyClosed (lifecycleManager, info, reason) {\n        if (typeof this._onProxyClosed === 'function') {\n            this._onProxyClosed(lifecycleManager, info, reason);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     */\n    onServiceStarted (serviceType, sessionID, correlationID) {\n        if (typeof this._onProtocolSessionEndedNACKed === 'function') {\n            this._onServiceStarted(serviceType, sessionID, correlationID);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     */\n    onServiceEnded (serviceType) {\n        if (typeof this._onServiceEnded === 'function') {\n            this._onServiceEnded(serviceType);\n        }\n    }\n\n    /**\n     * @param {LifecycleManager} lifecycleManager\n     * @param {String} info\n     */\n    onError (lifecycleManager, info) {\n        if (typeof this._onError === 'function') {\n            this._onError(lifecycleManager, info);\n        }\n    }\n}\n\nexport { LifecycleListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        // intentionally empty\n    }\n\n    /**\n    * Returns the key for a given value if the value is found within the key:value map\n    * @param value - A primitive value to find in the map\n    * @param map {Object} - An map of string properties to primitive values\n    * @return {null|String} - Returns null if not found\n    */\n    static _keyForValue (value, map) {\n        for (const key in map) {\n            if (map[key] === value) {\n                return key;\n            }\n        }\n\n        return null;\n    }\n\n    /**\n    * A method for subclasses to implement that does what _keyForValue does\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    keyForValue (value) {\n        throw new Error('method must be overridden');\n    }\n\n    /**\n    * Returns the value for the given key if the key is found within the key:value map\n    * @param value - A primitive value to find in the map\n    * @param map {Object} - An map of string properties to primitive values\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static _valueForKey (key, map) {\n        return map[key] || null;\n    }\n\n    /**\n    * A method for subclasses to implement that does what _valueForKey does\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    valueForKey (key) {\n        throw new Error('method must be overridden');\n    }\n}\n\nexport { Enum };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../util/Enum.js';\n\nclass RpcStruct {\n    /**\n    * @constructor\n    */\n    constructor (parameters = {}) {\n        this._isFormatRequested = false;\n        this._rpcSpecVersion = null;\n        this._parameters = parameters || {};\n    }\n\n    /**\n    * @return {Object}\n    */\n    getParameters () {\n        return this._parameters;\n    }\n\n    /**\n    * @param {String} key\n    * @return {*}\n    */\n    getParameter (key) {\n        return this._parameters[key];\n    }\n\n    /**\n    * @param {String} key\n    * @param {*} value\n    * @return {RpcStruct}\n    */\n    setParameter (key, value) {\n        if (value === null) {\n            delete this._parameters[key];\n        } else {\n            this._parameters[key] = value;\n        }\n\n        return this;\n    }\n\n    /**\n    * @param {Function} tClass\n    * @param {String} key\n    * @return {Object}\n    */\n    getObject (tClass, key) {\n        return this._formatObject(tClass, this.getParameter(key));\n    }\n\n    /**\n    * @param {Function} tClass\n    * @param {Object} obj\n    * @private\n    * @return {null|Object}\n    */\n    _formatObject (tClass, obj) {\n        if (obj === null || obj === undefined) {\n            return null;\n        } else if (obj.constructor === tClass) {\n            // if tClass is String and obj is a String, this should execute\n            return obj;\n        } else if (obj.constructor === String) { // this covers the Enum case too\n            return obj;\n        } else if (obj.constructor === Object) {\n            if (tClass.prototype instanceof RpcStruct) {\n                return new tClass(obj);\n            }\n            return null;\n        } else if (obj.constructor === Array) {\n            if (obj.length > 0) {\n                const outArray = [];\n                for (const item of obj) {\n                    outArray.push(this._formatObject(tClass, item));\n                }\n                return outArray;\n            }\n        }\n        return null;\n    }\n\n    /**\n    * @param {Function} tClass\n    * @param {Object} obj\n    * @param {Boolean} isArray (false)\n    */\n    validateType (tClass, obj, isArray = false) {\n        if (isArray) {\n            if (!Array.isArray(obj)) {\n                throw new Error(`${obj.name} must be an array containing items of type ${tClass.name}`);\n            } else {\n                for (const item of obj) {\n                    this.validateType(tClass, item, false);\n                }\n            }\n        } else if (\n            (tClass.prototype instanceof Enum && tClass.keyForValue(obj) === null)\n            || (tClass.prototype instanceof RpcStruct && obj !== null && obj.constructor !== tClass)\n        ) {\n            throw new Error(`${obj.name} must be of type ${tClass.name}`);\n        }\n    }\n}\n\nexport { RpcStruct };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Contains detailed information about the registered application.\n */\nclass AppInfo extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - The name displayed for the mobile application on the mobile device (can differ from the\n     *                        app name set in the initial RAI request).\n     * @return {AppInfo}\n     */\n    setAppDisplayName (name) {\n        this.setParameter(AppInfo.KEY_APP_DISPLAY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppDisplayName () {\n        return this.getParameter(AppInfo.KEY_APP_DISPLAY_NAME);\n    }\n\n    /**\n     * @param {String} id - The AppBundleID of an iOS application or package name of the Android application. This\n     *                      supports App Launch strategies for each platform.\n     * @return {AppInfo}\n     */\n    setAppBundleID (id) {\n        this.setParameter(AppInfo.KEY_APP_BUNDLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppBundleID () {\n        return this.getParameter(AppInfo.KEY_APP_BUNDLE_ID);\n    }\n\n    /**\n     * @param {String} version - Represents the build version number of this particular mobile app.\n     * @return {AppInfo}\n     */\n    setAppVersion (version) {\n        this.setParameter(AppInfo.KEY_APP_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppVersion () {\n        return this.getParameter(AppInfo.KEY_APP_VERSION);\n    }\n\n    /**\n     * @param {String} icon - A file reference to the icon utilized by this app (simplifies the process of setting an\n     *                        app icon during app registration).\n     * @return {AppInfo}\n     */\n    setAppIcon (icon) {\n        this.setParameter(AppInfo.KEY_APP_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppIcon () {\n        return this.getParameter(AppInfo.KEY_APP_ICON);\n    }\n}\n\nAppInfo.KEY_APP_DISPLAY_NAME = 'appDisplayName';\nAppInfo.KEY_APP_BUNDLE_ID = 'appBundleID';\nAppInfo.KEY_APP_VERSION = 'appVersion';\nAppInfo.KEY_APP_ICON = 'appIcon';\n\nexport { AppInfo };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass RGBColor extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} red\n     * @return {RGBColor}\n     */\n    setRed (red) {\n        this.setParameter(RGBColor.KEY_RED, red);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRed () {\n        return this.getParameter(RGBColor.KEY_RED);\n    }\n\n    /**\n     * @param {Number} green\n     * @return {RGBColor}\n     */\n    setGreen (green) {\n        this.setParameter(RGBColor.KEY_GREEN, green);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getGreen () {\n        return this.getParameter(RGBColor.KEY_GREEN);\n    }\n\n    /**\n     * @param {Number} blue\n     * @return {RGBColor}\n     */\n    setBlue (blue) {\n        this.setParameter(RGBColor.KEY_BLUE, blue);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getBlue () {\n        return this.getParameter(RGBColor.KEY_BLUE);\n    }\n}\n\nRGBColor.KEY_RED = 'red';\nRGBColor.KEY_GREEN = 'green';\nRGBColor.KEY_BLUE = 'blue';\n\nexport { RGBColor };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { RGBColor } from './RGBColor.js';\n\n/**\n * A color scheme for all display layout templates.\n */\nclass TemplateColorScheme extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {RGBColor} color - The primary \"accent\" color\n     * @return {TemplateColorScheme}\n     */\n    setPrimaryColor (color) {\n        this.validateType(RGBColor, color);\n        this.setParameter(TemplateColorScheme.KEY_PRIMARY_COLOR, color);\n        return this;\n    }\n\n    /**\n     * @return {RGBColor}\n     */\n    getPrimaryColor () {\n        return this.getObject(RGBColor, TemplateColorScheme.KEY_PRIMARY_COLOR);\n    }\n\n    /**\n     * @param {RGBColor} color - The secondary \"accent\" color\n     * @return {TemplateColorScheme}\n     */\n    setSecondaryColor (color) {\n        this.validateType(RGBColor, color);\n        this.setParameter(TemplateColorScheme.KEY_SECONDARY_COLOR, color);\n        return this;\n    }\n\n    /**\n     * @return {RGBColor}\n     */\n    getSecondaryColor () {\n        return this.getObject(RGBColor, TemplateColorScheme.KEY_SECONDARY_COLOR);\n    }\n\n    /**\n     * @param {RGBColor} color - The color of the background\n     * @return {TemplateColorScheme}\n     */\n    setBackgroundColor (color) {\n        this.validateType(RGBColor, color);\n        this.setParameter(TemplateColorScheme.KEY_BACKGROUND_COLOR, color);\n        return this;\n    }\n\n    /**\n     * @return {RGBColor}\n     */\n    getBackgroundColor () {\n        return this.getObject(RGBColor, TemplateColorScheme.KEY_BACKGROUND_COLOR);\n    }\n}\n\nTemplateColorScheme.KEY_PRIMARY_COLOR = 'primaryColor';\nTemplateColorScheme.KEY_SECONDARY_COLOR = 'secondaryColor';\nTemplateColorScheme.KEY_BACKGROUND_COLOR = 'backgroundColor';\n\nexport { TemplateColorScheme };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration linking function names with function IDs in SmartDeviceLink protocol. Assumes enumeration starts at\n * value 0.\n * @typedef {Enum} FunctionID\n * @property {Object} _MAP\n */\nclass FunctionID extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get RESERVED () {\n        return FunctionID._MAP.RESERVED;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get RegisterAppInterface () {\n        return FunctionID._MAP.RegisterAppInterface;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get UnregisterAppInterface () {\n        return FunctionID._MAP.UnregisterAppInterface;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SetGlobalProperties () {\n        return FunctionID._MAP.SetGlobalProperties;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ResetGlobalProperties () {\n        return FunctionID._MAP.ResetGlobalProperties;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get AddCommand () {\n        return FunctionID._MAP.AddCommand;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get DeleteCommand () {\n        return FunctionID._MAP.DeleteCommand;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get AddSubMenu () {\n        return FunctionID._MAP.AddSubMenu;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get DeleteSubMenu () {\n        return FunctionID._MAP.DeleteSubMenu;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get CreateInteractionChoiceSet () {\n        return FunctionID._MAP.CreateInteractionChoiceSet;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get PerformInteraction () {\n        return FunctionID._MAP.PerformInteraction;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get DeleteInteractionChoiceSet () {\n        return FunctionID._MAP.DeleteInteractionChoiceSet;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get Alert () {\n        return FunctionID._MAP.Alert;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get Show () {\n        return FunctionID._MAP.Show;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get Speak () {\n        return FunctionID._MAP.Speak;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SetMediaClockTimer () {\n        return FunctionID._MAP.SetMediaClockTimer;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get PerformAudioPassThru () {\n        return FunctionID._MAP.PerformAudioPassThru;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get EndAudioPassThru () {\n        return FunctionID._MAP.EndAudioPassThru;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SubscribeButton () {\n        return FunctionID._MAP.SubscribeButton;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get UnsubscribeButton () {\n        return FunctionID._MAP.UnsubscribeButton;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SubscribeVehicleData () {\n        return FunctionID._MAP.SubscribeVehicleData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get UnsubscribeVehicleData () {\n        return FunctionID._MAP.UnsubscribeVehicleData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetVehicleData () {\n        return FunctionID._MAP.GetVehicleData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ReadDID () {\n        return FunctionID._MAP.ReadDID;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetDTCs () {\n        return FunctionID._MAP.GetDTCs;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ScrollableMessage () {\n        return FunctionID._MAP.ScrollableMessage;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get Slider () {\n        return FunctionID._MAP.Slider;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ShowConstantTBT () {\n        return FunctionID._MAP.ShowConstantTBT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get AlertManeuver () {\n        return FunctionID._MAP.AlertManeuver;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get UpdateTurnList () {\n        return FunctionID._MAP.UpdateTurnList;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ChangeRegistration () {\n        return FunctionID._MAP.ChangeRegistration;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GenericResponse () {\n        return FunctionID._MAP.GenericResponse;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get PutFile () {\n        return FunctionID._MAP.PutFile;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get DeleteFile () {\n        return FunctionID._MAP.DeleteFile;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ListFiles () {\n        return FunctionID._MAP.ListFiles;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SetAppIcon () {\n        return FunctionID._MAP.SetAppIcon;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SetDisplayLayout () {\n        return FunctionID._MAP.SetDisplayLayout;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get DiagnosticMessage () {\n        return FunctionID._MAP.DiagnosticMessage;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SystemRequest () {\n        return FunctionID._MAP.SystemRequest;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SendLocation () {\n        return FunctionID._MAP.SendLocation;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get DialNumber () {\n        return FunctionID._MAP.DialNumber;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ButtonPress () {\n        return FunctionID._MAP.ButtonPress;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetInteriorVehicleData () {\n        return FunctionID._MAP.GetInteriorVehicleData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SetInteriorVehicleData () {\n        return FunctionID._MAP.SetInteriorVehicleData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetWayPoints () {\n        return FunctionID._MAP.GetWayPoints;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SubscribeWayPoints () {\n        return FunctionID._MAP.SubscribeWayPoints;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get UnsubscribeWayPoints () {\n        return FunctionID._MAP.UnsubscribeWayPoints;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetSystemCapability () {\n        return FunctionID._MAP.GetSystemCapability;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SendHapticData () {\n        return FunctionID._MAP.SendHapticData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SetCloudAppProperties () {\n        return FunctionID._MAP.SetCloudAppProperties;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetCloudAppProperties () {\n        return FunctionID._MAP.GetCloudAppProperties;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get PublishAppService () {\n        return FunctionID._MAP.PublishAppService;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetAppServiceData () {\n        return FunctionID._MAP.GetAppServiceData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetFile () {\n        return FunctionID._MAP.GetFile;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get PerformAppServiceInteraction () {\n        return FunctionID._MAP.PerformAppServiceInteraction;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get UnpublishAppService () {\n        return FunctionID._MAP.UnpublishAppService;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get CancelInteraction () {\n        return FunctionID._MAP.CancelInteraction;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get CloseApplication () {\n        return FunctionID._MAP.CloseApplication;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ShowAppMenu () {\n        return FunctionID._MAP.ShowAppMenu;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get CreateWindow () {\n        return FunctionID._MAP.CreateWindow;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get DeleteWindow () {\n        return FunctionID._MAP.DeleteWindow;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get GetInteriorVehicleDataConsent () {\n        return FunctionID._MAP.GetInteriorVehicleDataConsent;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get ReleaseInteriorVehicleDataModule () {\n        return FunctionID._MAP.ReleaseInteriorVehicleDataModule;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnHMIStatus () {\n        return FunctionID._MAP.OnHMIStatus;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnAppInterfaceUnregistered () {\n        return FunctionID._MAP.OnAppInterfaceUnregistered;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnButtonEvent () {\n        return FunctionID._MAP.OnButtonEvent;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnButtonPress () {\n        return FunctionID._MAP.OnButtonPress;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnVehicleData () {\n        return FunctionID._MAP.OnVehicleData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnCommand () {\n        return FunctionID._MAP.OnCommand;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnTBTClientState () {\n        return FunctionID._MAP.OnTBTClientState;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnDriverDistraction () {\n        return FunctionID._MAP.OnDriverDistraction;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnPermissionsChange () {\n        return FunctionID._MAP.OnPermissionsChange;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnAudioPassThru () {\n        return FunctionID._MAP.OnAudioPassThru;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnLanguageChange () {\n        return FunctionID._MAP.OnLanguageChange;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnKeyboardInput () {\n        return FunctionID._MAP.OnKeyboardInput;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnTouchEvent () {\n        return FunctionID._MAP.OnTouchEvent;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnSystemRequest () {\n        return FunctionID._MAP.OnSystemRequest;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnHashChange () {\n        return FunctionID._MAP.OnHashChange;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnInteriorVehicleData () {\n        return FunctionID._MAP.OnInteriorVehicleData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnWayPointChange () {\n        return FunctionID._MAP.OnWayPointChange;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnRCStatus () {\n        return FunctionID._MAP.OnRCStatus;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnAppServiceData () {\n        return FunctionID._MAP.OnAppServiceData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnSystemCapabilityUpdated () {\n        return FunctionID._MAP.OnSystemCapabilityUpdated;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get EncodedSyncPData () {\n        return FunctionID._MAP.EncodedSyncPData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SdlPData () {\n        return FunctionID._MAP.SdlPData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnEncodedSyncPData () {\n        return FunctionID._MAP.OnEncodedSyncPData;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OnSyncPData () {\n        return FunctionID._MAP.OnSyncPData;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return FunctionID._valueForKey(key, FunctionID._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return FunctionID._keyForValue(value, FunctionID._MAP);\n    }\n}\n\nFunctionID._MAP = Object.freeze({\n    'RESERVED': 0,\n    'RegisterAppInterface': 0x01,\n    'UnregisterAppInterface': 0x02,\n    'SetGlobalProperties': 0x03,\n    'ResetGlobalProperties': 0x04,\n    'AddCommand': 0x05,\n    'DeleteCommand': 0x06,\n    'AddSubMenu': 0x07,\n    'DeleteSubMenu': 0x08,\n    'CreateInteractionChoiceSet': 0x09,\n    'PerformInteraction': 0x0A,\n    'DeleteInteractionChoiceSet': 0x0B,\n    'Alert': 0x0C,\n    'Show': 0x0D,\n    'Speak': 0x0E,\n    'SetMediaClockTimer': 0x0F,\n    'PerformAudioPassThru': 0x10,\n    'EndAudioPassThru': 0x11,\n    'SubscribeButton': 0x12,\n    'UnsubscribeButton': 0x13,\n    'SubscribeVehicleData': 0x14,\n    'UnsubscribeVehicleData': 0x15,\n    'GetVehicleData': 0x16,\n    'ReadDID': 0x17,\n    'GetDTCs': 0x18,\n    'ScrollableMessage': 0x19,\n    'Slider': 0x1A,\n    'ShowConstantTBT': 0x1B,\n    'AlertManeuver': 0x1C,\n    'UpdateTurnList': 0x1D,\n    'ChangeRegistration': 0x1E,\n    'GenericResponse': 0x1F,\n    'PutFile': 0x20,\n    'DeleteFile': 0x21,\n    'ListFiles': 0x22,\n    'SetAppIcon': 0x23,\n    'SetDisplayLayout': 0x24,\n    'DiagnosticMessage': 0x25,\n    'SystemRequest': 0x26,\n    'SendLocation': 0x27,\n    'DialNumber': 0x28,\n    'ButtonPress': 0x29,\n    'GetInteriorVehicleData': 0x2B,\n    'SetInteriorVehicleData': 0x2C,\n    'GetWayPoints': 0x2D,\n    'SubscribeWayPoints': 0x2E,\n    'UnsubscribeWayPoints': 0x2F,\n    'GetSystemCapability': 0x30,\n    'SendHapticData': 0x31,\n    'SetCloudAppProperties': 0x32,\n    'GetCloudAppProperties': 0x33,\n    'PublishAppService': 0x34,\n    'GetAppServiceData': 0x35,\n    'GetFile': 0x36,\n    'PerformAppServiceInteraction': 0x37,\n    'UnpublishAppService': 0x38,\n    'CancelInteraction': 0x39,\n    'CloseApplication': 0x3A,\n    'ShowAppMenu': 0x3B,\n    'CreateWindow': 0x3C,\n    'DeleteWindow': 0x3D,\n    'GetInteriorVehicleDataConsent': 0x3E,\n    'ReleaseInteriorVehicleDataModule': 0x3F,\n    'OnHMIStatus': 0x8000,\n    'OnAppInterfaceUnregistered': 0x8001,\n    'OnButtonEvent': 0x8002,\n    'OnButtonPress': 0x8003,\n    'OnVehicleData': 0x8004,\n    'OnCommand': 0x8005,\n    'OnTBTClientState': 0x8006,\n    'OnDriverDistraction': 0x8007,\n    'OnPermissionsChange': 0x8008,\n    'OnAudioPassThru': 0x8009,\n    'OnLanguageChange': 0x800A,\n    'OnKeyboardInput': 0x800B,\n    'OnTouchEvent': 0x800C,\n    'OnSystemRequest': 0x800D,\n    'OnHashChange': 0x800E,\n    'OnInteriorVehicleData': 0x800F,\n    'OnWayPointChange': 0x8010,\n    'OnRCStatus': 0x8011,\n    'OnAppServiceData': 0x8012,\n    'OnSystemCapabilityUpdated': 0x8013,\n    'EncodedSyncPData': 0x10000,\n    'SyncPData': 0x10001,\n    'OnEncodedSyncPData': 0x18000,\n    'OnSyncPData': 0x18001,\n});\n\nexport { FunctionID };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Contains information about the TTS capabilities.\n * @typedef {Enum} SpeechCapabilities\n * @property {Object} _MAP\n */\nclass SpeechCapabilities extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SC_TEXT () {\n        return SpeechCapabilities._MAP.SC_TEXT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SAPI_PHONEMES () {\n        return SpeechCapabilities._MAP.SAPI_PHONEMES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LHPLUS_PHONEMES () {\n        return SpeechCapabilities._MAP.LHPLUS_PHONEMES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRE_RECORDED () {\n        return SpeechCapabilities._MAP.PRE_RECORDED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SILENCE () {\n        return SpeechCapabilities._MAP.SILENCE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FILE () {\n        return SpeechCapabilities._MAP.FILE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SpeechCapabilities._valueForKey(key, SpeechCapabilities._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SpeechCapabilities._keyForValue(value, SpeechCapabilities._MAP);\n    }\n}\n\nSpeechCapabilities._MAP = Object.freeze({\n    'SC_TEXT': 'TEXT',\n    'SAPI_PHONEMES': 'SAPI_PHONEMES',\n    'LHPLUS_PHONEMES': 'LHPLUS_PHONEMES',\n    'PRE_RECORDED': 'PRE_RECORDED',\n    'SILENCE': 'SILENCE',\n    'FILE': 'FILE',\n});\n\nexport { SpeechCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SpeechCapabilities } from '../enums/SpeechCapabilities.js';\n\n/**\n * A TTS chunk, that consists of text/phonemes to speak or the name of a file to play, and a TTS type (like text or\n * SAPI)\n */\nclass TTSChunk extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} text - The text or phonemes to speak, or the name of the audio file to play. May not be empty.\n     * @return {TTSChunk}\n     */\n    setText (text) {\n        this.setParameter(TTSChunk.KEY_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getText () {\n        return this.getParameter(TTSChunk.KEY_TEXT);\n    }\n\n    /**\n     * @param {SpeechCapabilities} type - Describes whether the TTS chunk is plain text, a specific phoneme set, or an\n     *                                    audio file. See SpeechCapabilities\n     * @return {TTSChunk}\n     */\n    setType (type) {\n        this.validateType(SpeechCapabilities, type);\n        this.setParameter(TTSChunk.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {SpeechCapabilities}\n     */\n    getType () {\n        return this.getObject(SpeechCapabilities, TTSChunk.KEY_TYPE);\n    }\n}\n\nTTSChunk.KEY_TEXT = 'text';\nTTSChunk.KEY_TYPE = 'type';\n\nexport { TTSChunk };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Specifies the version number of the SmartDeviceLink protocol that is supported by the mobile application\n */\nclass SdlMsgVersion extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} version - The major version indicates versions that is not-compatible to previous versions.\n     * @return {SdlMsgVersion}\n     */\n    setMajorVersion (version) {\n        this.setParameter(SdlMsgVersion.KEY_MAJOR_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMajorVersion () {\n        return this.getParameter(SdlMsgVersion.KEY_MAJOR_VERSION);\n    }\n\n    /**\n     * @param {Number} version - The minor version indicates a change to a previous version that should still allow to\n     *                           be run on an older version (with limited functionality)\n     * @return {SdlMsgVersion}\n     */\n    setMinorVersion (version) {\n        this.setParameter(SdlMsgVersion.KEY_MINOR_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMinorVersion () {\n        return this.getParameter(SdlMsgVersion.KEY_MINOR_VERSION);\n    }\n\n    /**\n     * @param {Number} version - The patch version indicates a fix to existing functionality in a previous version that\n     *                           should still be able to be run on an older version\n     * @return {SdlMsgVersion}\n     */\n    setPatchVersion (version) {\n        this.setParameter(SdlMsgVersion.KEY_PATCH_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPatchVersion () {\n        return this.getParameter(SdlMsgVersion.KEY_PATCH_VERSION);\n    }\n}\n\nSdlMsgVersion.KEY_MAJOR_VERSION = 'majorVersion';\nSdlMsgVersion.KEY_MINOR_VERSION = 'minorVersion';\nSdlMsgVersion.KEY_PATCH_VERSION = 'patchVersion';\n\nexport { SdlMsgVersion };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration listing possible app types.\n * @typedef {Enum} AppHMIType\n * @property {Object} _MAP\n */\nclass AppHMIType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFAULT () {\n        return AppHMIType._MAP.DEFAULT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get COMMUNICATION () {\n        return AppHMIType._MAP.COMMUNICATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MEDIA () {\n        return AppHMIType._MAP.MEDIA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MESSAGING () {\n        return AppHMIType._MAP.MESSAGING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAVIGATION () {\n        return AppHMIType._MAP.NAVIGATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INFORMATION () {\n        return AppHMIType._MAP.INFORMATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SOCIAL () {\n        return AppHMIType._MAP.SOCIAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BACKGROUND_PROCESS () {\n        return AppHMIType._MAP.BACKGROUND_PROCESS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TESTING () {\n        return AppHMIType._MAP.TESTING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SYSTEM () {\n        return AppHMIType._MAP.SYSTEM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PROJECTION () {\n        return AppHMIType._MAP.PROJECTION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REMOTE_CONTROL () {\n        return AppHMIType._MAP.REMOTE_CONTROL;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return AppHMIType._valueForKey(key, AppHMIType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return AppHMIType._keyForValue(value, AppHMIType._MAP);\n    }\n}\n\nAppHMIType._MAP = Object.freeze({\n    'DEFAULT': 'DEFAULT',\n    'COMMUNICATION': 'COMMUNICATION',\n    'MEDIA': 'MEDIA',\n    'MESSAGING': 'MESSAGING',\n    'NAVIGATION': 'NAVIGATION',\n    'INFORMATION': 'INFORMATION',\n    'SOCIAL': 'SOCIAL',\n    'BACKGROUND_PROCESS': 'BACKGROUND_PROCESS',\n    'TESTING': 'TESTING',\n    'SYSTEM': 'SYSTEM',\n    'PROJECTION': 'PROJECTION',\n    'REMOTE_CONTROL': 'REMOTE_CONTROL',\n});\n\nexport { AppHMIType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} Language\n * @property {Object} _MAP\n */\nclass Language extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * English - US\n     * @return {String}\n     */\n    static get EN_US () {\n        return Language._MAP.EN_US;\n    }\n\n    /**\n     * Spanish - Mexico\n     * @return {String}\n     */\n    static get ES_MX () {\n        return Language._MAP.ES_MX;\n    }\n\n    /**\n     * French - Canada\n     * @return {String}\n     */\n    static get FR_CA () {\n        return Language._MAP.FR_CA;\n    }\n\n    /**\n     * German - Germany\n     * @return {String}\n     */\n    static get DE_DE () {\n        return Language._MAP.DE_DE;\n    }\n\n    /**\n     * Spanish - Spain\n     * @return {String}\n     */\n    static get ES_ES () {\n        return Language._MAP.ES_ES;\n    }\n\n    /**\n     * English - GB\n     * @return {String}\n     */\n    static get EN_GB () {\n        return Language._MAP.EN_GB;\n    }\n\n    /**\n     * Russian - Russia\n     * @return {String}\n     */\n    static get RU_RU () {\n        return Language._MAP.RU_RU;\n    }\n\n    /**\n     * Turkish - Turkey\n     * @return {String}\n     */\n    static get TR_TR () {\n        return Language._MAP.TR_TR;\n    }\n\n    /**\n     * Polish - Poland\n     * @return {String}\n     */\n    static get PL_PL () {\n        return Language._MAP.PL_PL;\n    }\n\n    /**\n     * French - France\n     * @return {String}\n     */\n    static get FR_FR () {\n        return Language._MAP.FR_FR;\n    }\n\n    /**\n     * Italian - Italy\n     * @return {String}\n     */\n    static get IT_IT () {\n        return Language._MAP.IT_IT;\n    }\n\n    /**\n     * Swedish - Sweden\n     * @return {String}\n     */\n    static get SV_SE () {\n        return Language._MAP.SV_SE;\n    }\n\n    /**\n     * Portuguese - Portugal\n     * @return {String}\n     */\n    static get PT_PT () {\n        return Language._MAP.PT_PT;\n    }\n\n    /**\n     * Dutch (Standard) - Netherlands\n     * @return {String}\n     */\n    static get NL_NL () {\n        return Language._MAP.NL_NL;\n    }\n\n    /**\n     * English - Australia\n     * @return {String}\n     */\n    static get EN_AU () {\n        return Language._MAP.EN_AU;\n    }\n\n    /**\n     * Mandarin - China\n     * @return {String}\n     */\n    static get ZH_CN () {\n        return Language._MAP.ZH_CN;\n    }\n\n    /**\n     * Mandarin - Taiwan\n     * @return {String}\n     */\n    static get ZH_TW () {\n        return Language._MAP.ZH_TW;\n    }\n\n    /**\n     * Japanese - Japan\n     * @return {String}\n     */\n    static get JA_JP () {\n        return Language._MAP.JA_JP;\n    }\n\n    /**\n     * Arabic - Saudi Arabia\n     * @return {String}\n     */\n    static get AR_SA () {\n        return Language._MAP.AR_SA;\n    }\n\n    /**\n     * Korean - South Korea\n     * @return {String}\n     */\n    static get KO_KR () {\n        return Language._MAP.KO_KR;\n    }\n\n    /**\n     * Portuguese - Brazil\n     * @return {String}\n     */\n    static get PT_BR () {\n        return Language._MAP.PT_BR;\n    }\n\n    /**\n     * Czech - Czech Republic\n     * @return {String}\n     */\n    static get CS_CZ () {\n        return Language._MAP.CS_CZ;\n    }\n\n    /**\n     * Danish - Denmark\n     * @return {String}\n     */\n    static get DA_DK () {\n        return Language._MAP.DA_DK;\n    }\n\n    /**\n     * Norwegian - Norway\n     * @return {String}\n     */\n    static get NO_NO () {\n        return Language._MAP.NO_NO;\n    }\n\n    /**\n     * Dutch (Flemish) - Belgium\n     * @return {String}\n     */\n    static get NL_BE () {\n        return Language._MAP.NL_BE;\n    }\n\n    /**\n     * Greek - Greece\n     * @return {String}\n     */\n    static get EL_GR () {\n        return Language._MAP.EL_GR;\n    }\n\n    /**\n     * Hungarian - Hungary\n     * @return {String}\n     */\n    static get HU_HU () {\n        return Language._MAP.HU_HU;\n    }\n\n    /**\n     * Finnish - Finland\n     * @return {String}\n     */\n    static get FI_FI () {\n        return Language._MAP.FI_FI;\n    }\n\n    /**\n     * Slovak - Slovakia\n     * @return {String}\n     */\n    static get SK_SK () {\n        return Language._MAP.SK_SK;\n    }\n\n    /**\n     * English - India\n     * @return {String}\n     */\n    static get EN_IN () {\n        return Language._MAP.EN_IN;\n    }\n\n    /**\n     * Thai - Thailand\n     * @return {String}\n     */\n    static get TH_TH () {\n        return Language._MAP.TH_TH;\n    }\n\n    /**\n     * English - Middle East\n     * @return {String}\n     */\n    static get EN_SA () {\n        return Language._MAP.EN_SA;\n    }\n\n    /**\n     * Hebrew - Israel\n     * @return {String}\n     */\n    static get HE_IL () {\n        return Language._MAP.HE_IL;\n    }\n\n    /**\n     * Romanian - Romania\n     * @return {String}\n     */\n    static get RO_RO () {\n        return Language._MAP.RO_RO;\n    }\n\n    /**\n     * Ukrainian - Ukraine\n     * @return {String}\n     */\n    static get UK_UA () {\n        return Language._MAP.UK_UA;\n    }\n\n    /**\n     * Indonesian - Indonesia\n     * @return {String}\n     */\n    static get ID_ID () {\n        return Language._MAP.ID_ID;\n    }\n\n    /**\n     * Vietnamese - Vietnam\n     * @return {String}\n     */\n    static get VI_VN () {\n        return Language._MAP.VI_VN;\n    }\n\n    /**\n     * Malay - Malaysia\n     * @return {String}\n     */\n    static get MS_MY () {\n        return Language._MAP.MS_MY;\n    }\n\n    /**\n     * Hindi - India\n     * @return {String}\n     */\n    static get HI_IN () {\n        return Language._MAP.HI_IN;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return Language._valueForKey(key, Language._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return Language._keyForValue(value, Language._MAP);\n    }\n}\n\nLanguage._MAP = Object.freeze({\n    'EN_US': 'EN-US',\n    'ES_MX': 'ES-MX',\n    'FR_CA': 'FR-CA',\n    'DE_DE': 'DE-DE',\n    'ES_ES': 'ES-ES',\n    'EN_GB': 'EN-GB',\n    'RU_RU': 'RU-RU',\n    'TR_TR': 'TR-TR',\n    'PL_PL': 'PL-PL',\n    'FR_FR': 'FR-FR',\n    'IT_IT': 'IT-IT',\n    'SV_SE': 'SV-SE',\n    'PT_PT': 'PT-PT',\n    'NL_NL': 'NL-NL',\n    'EN_AU': 'EN-AU',\n    'ZH_CN': 'ZH-CN',\n    'ZH_TW': 'ZH-TW',\n    'JA_JP': 'JA-JP',\n    'AR_SA': 'AR-SA',\n    'KO_KR': 'KO-KR',\n    'PT_BR': 'PT-BR',\n    'CS_CZ': 'CS-CZ',\n    'DA_DK': 'DA-DK',\n    'NO_NO': 'NO-NO',\n    'NL_BE': 'NL-BE',\n    'EL_GR': 'EL-GR',\n    'HU_HU': 'HU-HU',\n    'FI_FI': 'FI-FI',\n    'SK_SK': 'SK-SK',\n    'EN_IN': 'EN-IN',\n    'TH_TH': 'TH-TH',\n    'EN_SA': 'EN-SA',\n    'HE_IL': 'HE-IL',\n    'RO_RO': 'RO-RO',\n    'UK_UA': 'UK-UA',\n    'ID_ID': 'ID-ID',\n    'VI_VN': 'VI-VN',\n    'MS_MY': 'MS-MY',\n    'HI_IN': 'HI-IN',\n});\n\nexport { Language };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from './RpcStruct.js';\nimport { FunctionID } from './enums/FunctionID.js';\n\n/**\n * @typedef {Object} RpcMessage\n * @property {RpcType} rpcType\n */\nclass RpcMessage extends RpcStruct {\n    /*\n    {\n        \"rpcType\": \"Request\",\n        \"functionName\": \"RegisterAppInterface\",\n        \"coorelationID\": \"320948\",\n        \"isEncrypted\": false,\n        \"parameters\": {\n            \"appName\": \"Hello\"\n        },\n        \"bulkData\": \"...\",\n    }\n    */\n\n    /**\n    * @constructor\n    */\n    constructor (store = {}) {\n        super(store.parameters);\n        this._isEncrypted = false;\n        this._rpcType = store.rpcType;\n        this._functionName = store.functionName;\n        this._correlationID = store.correlationID;\n        this.setBulkData(store.bulkData);\n    }\n\n    /**\n    * @return {RpcType}\n    */\n    getRPCType () {\n        return this._rpcType;\n    }\n\n    /**\n    * @param {RpcType} type\n    * @return {RpcMessage}\n    */\n    setRPCType (type) {\n        this._rpcType = type;\n\n        return this;\n    }\n\n    /**\n    * @return {FunctionID} type\n    */\n    getFunctionName () {\n        return this._functionName;\n    }\n\n    /**\n    * @param {FunctionID} name\n    * @return {RpcMessage}\n    */\n    setFunctionName (name) {\n        if (typeof name !== 'string') {\n            this._functionName = FunctionID.keyForValue(name);\n        } else {\n            this._functionName = name;\n        }\n\n        return this;\n    }\n\n    /**\n    * @return {String} type\n    */\n    getCorrelationId () {\n        return this._correlationID;\n    }\n\n    /**\n    * @param {String} name\n    * @return {RpcMessage}\n    */\n    setCorrelationId (id) {\n        this._correlationID = id;\n\n        return this;\n    }\n\n    /**\n    * @return {Uint8Array} data\n    */\n    getBulkData () {\n        return this._bulkData;\n    }\n\n    /**\n    * @param {UInt8Array} data\n    * @return {RpcMessage}\n    */\n    setBulkData (data = null) {\n        if (data !== null) {\n            this._bulkData = data.slice(0);\n        } else {\n            this._bulkData = null;\n        }\n\n        return this;\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getIsEncrypted () {\n        return this._isEncrypted;\n    }\n\n    /**\n    * @param {Boolean} bool\n    * @return {RpcMessage}\n    */\n    setIsEncrypted (bool) {\n        this._isEncrypted = bool;\n\n        return this;\n    }\n}\n\nexport { RpcMessage };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} RpcType\n * @property {Object} _MAP\n */\nclass RpcType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get NOTIFICATION () {\n        return RpcType._MAP.NOTIFICATION;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get RESPONSE () {\n        return RpcType._MAP.RESPONSE;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REQUEST () {\n        return RpcType._MAP.REQUEST;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return RpcType._valueForKey(key, RpcType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return RpcType._keyForValue(value, RpcType._MAP);\n    }\n}\n\nRpcType._MAP = Object.freeze({\n    'NOTIFICATION': 0x2,\n    'RESPONSE': 0x1,\n    'REQUEST': 0x0,\n});\n\nexport { RpcType };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n\nimport { RpcMessage } from './RpcMessage.js';\nimport { RpcType } from './enums/RpcType.js';\n\nclass RpcRequest extends RpcMessage {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setRPCType(RpcType.REQUEST);\n        this._promise = null;\n    }\n\n    /**\n    * @return {Promise}\n    */\n    getOnRPCResponsePromise () {\n        return this._promise;\n    }\n\n    /**\n    * @param {Promise} promise\n    * @return {RpcMessage}\n    */\n    setOnRPCResponsePromise (promise) {\n        this.validateType(Promise, promise);\n\n        this._promise = promise;\n        return this;\n    }\n}\n\nexport { RpcRequest };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Various information about connecting device.\n */\nclass DeviceInfo extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} hardware - Device model\n     * @return {DeviceInfo}\n     */\n    setHardware (hardware) {\n        this.setParameter(DeviceInfo.KEY_HARDWARE, hardware);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getHardware () {\n        return this.getParameter(DeviceInfo.KEY_HARDWARE);\n    }\n\n    /**\n     * @param {String} rev - Device firmware revision\n     * @return {DeviceInfo}\n     */\n    setFirmwareRev (rev) {\n        this.setParameter(DeviceInfo.KEY_FIRMWARE_REV, rev);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getFirmwareRev () {\n        return this.getParameter(DeviceInfo.KEY_FIRMWARE_REV);\n    }\n\n    /**\n     * @param {String} os - Device OS\n     * @return {DeviceInfo}\n     */\n    setOs (os) {\n        this.setParameter(DeviceInfo.KEY_OS, os);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getOs () {\n        return this.getParameter(DeviceInfo.KEY_OS);\n    }\n\n    /**\n     * @param {String} version - Device OS version\n     * @return {DeviceInfo}\n     */\n    setOsVersion (version) {\n        this.setParameter(DeviceInfo.KEY_OS_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getOsVersion () {\n        return this.getParameter(DeviceInfo.KEY_OS_VERSION);\n    }\n\n    /**\n     * @param {String} carrier - Device mobile carrier (if applicable)\n     * @return {DeviceInfo}\n     */\n    setCarrier (carrier) {\n        this.setParameter(DeviceInfo.KEY_CARRIER, carrier);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getCarrier () {\n        return this.getParameter(DeviceInfo.KEY_CARRIER);\n    }\n\n    /**\n     * @param {Number} ports - Omitted if connected not via BT.\n     * @return {DeviceInfo}\n     */\n    setMaxNumberRFCOMMPorts (ports) {\n        this.setParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS, ports);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaxNumberRFCOMMPorts () {\n        return this.getParameter(DeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS);\n    }\n}\n\nDeviceInfo.KEY_HARDWARE = 'hardware';\nDeviceInfo.KEY_FIRMWARE_REV = 'firmwareRev';\nDeviceInfo.KEY_OS = 'os';\nDeviceInfo.KEY_OS_VERSION = 'osVersion';\nDeviceInfo.KEY_CARRIER = 'carrier';\nDeviceInfo.KEY_MAX_NUMBER_RFCOMM_PORTS = 'maxNumberRFCOMMPorts';\n\nexport { DeviceInfo };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { AppInfo } from '../structs/AppInfo.js';\nimport { TemplateColorScheme } from '../structs/TemplateColorScheme.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { SdlMsgVersion } from '../structs/SdlMsgVersion.js';\nimport { AppHMIType } from '../enums/AppHMIType.js';\nimport { Language } from '../enums/Language.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { DeviceInfo } from '../structs/DeviceInfo.js';\n\n/**\n * Establishes an interface with a mobile application. Before registerAppInterface no other commands will be\n * accepted/executed.\n */\nclass RegisterAppInterface extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.RegisterAppInterface);\n    }\n\n    /**\n     * @param {String} fullAppId\n     * @return {RegisterAppInterface}\n     */\n    setFullAppId (fullAppId) {\n        this.validateType(String, fullAppId);\n\n        if (fullAppId !== null) {\n            fullAppId = fullAppId.toLowerCase();\n            this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, fullAppId);\n            let appID;\n            if (fullAppId.length <= RegisterAppInterface.APP_ID_MAX_LENGTH) {\n                appID = fullAppId;\n            } else {\n                appID = fullAppId.replace('-', '').substring(0, RegisterAppInterface.APP_ID_MAX_LENGTH);\n            }\n            this._setAppId(appID);\n        } else {\n            this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, null);\n        }\n\n        return this;\n    }\n\n    /**\n     * @return {String} the app id\n     */\n    getFullAppId () {\n        return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID);\n    }\n\n    /**\n     * @param {String} appId - This method should not be accessed directly by developers. Only set the full ID and this\n     *                         param will be set.\n     * @return {RegisterAppInterface}\n     */\n    _setAppId (appId) {\n        this.validateType(String, appId);\n\n        this.setParameter(RegisterAppInterface.KEY_APP_ID, appId);\n        return this;\n    }\n\n    /**\n     * @return {String} the app id\n     */\n    getAppId () {\n        return this.getParameter(RegisterAppInterface.KEY_APP_ID);\n    }\n\n    /**\n     * @param {SdlMsgVersion} version - See SyncMsgVersion\n     * @return {RegisterAppInterface}\n     */\n    setSdlMsgVersion (version) {\n        this.validateType(SdlMsgVersion, version);\n        this.setParameter(RegisterAppInterface.KEY_SDL_MSG_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {SdlMsgVersion}\n     */\n    getSdlMsgVersion () {\n        return this.getObject(SdlMsgVersion, RegisterAppInterface.KEY_SDL_MSG_VERSION);\n    }\n\n    /**\n     * @param {String} name - The mobile application name, e.g. \"My SDL App\". Needs to be unique over all applications\n     *                        from the same device. May not be empty. May not start with a new line character. May not\n     *                        interfere with any name or synonym of previously registered applications from the same\n     *                        device and any predefined blacklist of words (global commands) Additional applications\n     *                        with the same name from the same device will be rejected. Only characters from char set\n     * @return {RegisterAppInterface}\n     */\n    setAppName (name) {\n        this.setParameter(RegisterAppInterface.KEY_APP_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppName () {\n        return this.getParameter(RegisterAppInterface.KEY_APP_NAME);\n    }\n\n    /**\n     * @param {TTSChunk[]} name - TTS string for VR recognition of the mobile application name, e.g. \"My S D L App\".\n     *                            Meant to overcome any failing on speech engine in properly pronouncing / understanding\n     *                            app name. Needs to be unique over all applications from the same device. May not be\n     *                            empty. May not start with a new line character. Only characters from char set\n     * @return {RegisterAppInterface}\n     */\n    setTtsName (name) {\n        this.validateType(TTSChunk, name, true);\n        this.setParameter(RegisterAppInterface.KEY_TTS_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getTtsName () {\n        return this.getObject(TTSChunk, RegisterAppInterface.KEY_TTS_NAME);\n    }\n\n    /**\n     * @param {String} name - Provides an abbreviated version of the app name (if needed), that will be displayed on the\n     *                        NGN media screen. If not provided, the appName is used instead (and will be truncated if\n     *                        too long) Only characters from char set\n     * @return {RegisterAppInterface}\n     */\n    setNgnMediaScreenAppName (name) {\n        this.setParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getNgnMediaScreenAppName () {\n        return this.getParameter(RegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME);\n    }\n\n    /**\n     * @param {String[]} synonyms - Defines an additional voice recognition command. May not interfere with any app name\n     *                              of previously registered applications from the same device and any predefined\n     *                              blacklist of words (global commands) Only characters from char set\n     * @return {RegisterAppInterface}\n     */\n    setVrSynonyms (synonyms) {\n        this.setParameter(RegisterAppInterface.KEY_VR_SYNONYMS, synonyms);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getVrSynonyms () {\n        return this.getParameter(RegisterAppInterface.KEY_VR_SYNONYMS);\n    }\n\n    /**\n     * @param {Boolean} application - Indicates if the application is a media or a non-media application. Only media\n     *                                applications will be able to stream audio to the module that is audible outside of\n     *                                the BT media source.\n     * @return {RegisterAppInterface}\n     */\n    setIsMediaApplication (application) {\n        this.setParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION, application);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getIsMediaApplication () {\n        return this.getParameter(RegisterAppInterface.KEY_IS_MEDIA_APPLICATION);\n    }\n\n    /**\n     * @param {Language} desired - See Language Current app's expected VR+TTS language If there is a mismatch with the\n     *                             module, the app will be able to change this registration with changeRegistration\n     *                             prior to app being brought into focus.\n     * @return {RegisterAppInterface}\n     */\n    setLanguageDesired (desired) {\n        this.validateType(Language, desired);\n        this.setParameter(RegisterAppInterface.KEY_LANGUAGE_DESIRED, desired);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getLanguageDesired () {\n        return this.getObject(Language, RegisterAppInterface.KEY_LANGUAGE_DESIRED);\n    }\n\n    /**\n     * @param {Language} desired - See Language Current app's expected display language If there is a mismatch with the\n     *                             module, the app will be able to change this registration with changeRegistration\n     *                             prior to app being brought into focus.\n     * @return {RegisterAppInterface}\n     */\n    setHmiDisplayLanguageDesired (desired) {\n        this.validateType(Language, desired);\n        this.setParameter(RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED, desired);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getHmiDisplayLanguageDesired () {\n        return this.getObject(Language, RegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED);\n    }\n\n    /**\n     * @param {AppHMIType[]} type - See AppHMIType List of all applicable app HMI types stating which HMI\n     *                              classifications to be given to the app.\n     * @return {RegisterAppInterface}\n     */\n    setAppHMIType (type) {\n        this.validateType(AppHMIType, type, true);\n        this.setParameter(RegisterAppInterface.KEY_APP_HMI_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {AppHMIType[]}\n     */\n    getAppHMIType () {\n        return this.getObject(AppHMIType, RegisterAppInterface.KEY_APP_HMI_TYPE);\n    }\n\n    /**\n     * @param {String} id - ID used to uniquely identify current state of all app data that can persist through\n     *                      connection cycles (e.g. ignition cycles). This registered data (commands, submenus, choice\n     *                      sets, etc.) can be reestablished without needing to explicitly reregister each piece. If\n     *                      omitted, then the previous state of an app's commands, etc. will not be restored. When\n     *                      sending hashID, all RegisterAppInterface parameters should still be provided (e.g. ttsName,\n     *                      etc.).\n     * @return {RegisterAppInterface}\n     */\n    setHashID (id) {\n        this.setParameter(RegisterAppInterface.KEY_HASH_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getHashID () {\n        return this.getParameter(RegisterAppInterface.KEY_HASH_ID);\n    }\n\n    /**\n     * @param {DeviceInfo} info - See DeviceInfo.\n     * @return {RegisterAppInterface}\n     */\n    setDeviceInfo (info) {\n        this.validateType(DeviceInfo, info);\n        this.setParameter(RegisterAppInterface.KEY_DEVICE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {DeviceInfo}\n     */\n    getDeviceInfo () {\n        return this.getObject(DeviceInfo, RegisterAppInterface.KEY_DEVICE_INFO);\n    }\n\n    /**\n     * @param {String} id - ID used to validate app with policy table entries\n     * @return {RegisterAppInterface}\n     */\n    setFullAppID (id) {\n        this.setParameter(RegisterAppInterface.KEY_FULL_APP_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getFullAppID () {\n        return this.getParameter(RegisterAppInterface.KEY_FULL_APP_ID);\n    }\n\n    /**\n     * @param {AppInfo} info - See AppInfo.\n     * @return {RegisterAppInterface}\n     */\n    setAppInfo (info) {\n        this.validateType(AppInfo, info);\n        this.setParameter(RegisterAppInterface.KEY_APP_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {AppInfo}\n     */\n    getAppInfo () {\n        return this.getObject(AppInfo, RegisterAppInterface.KEY_APP_INFO);\n    }\n\n    /**\n     * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates.\n     * @return {RegisterAppInterface}\n     */\n    setDayColorScheme (scheme) {\n        this.validateType(TemplateColorScheme, scheme);\n        this.setParameter(RegisterAppInterface.KEY_DAY_COLOR_SCHEME, scheme);\n        return this;\n    }\n\n    /**\n     * @return {TemplateColorScheme}\n     */\n    getDayColorScheme () {\n        return this.getObject(TemplateColorScheme, RegisterAppInterface.KEY_DAY_COLOR_SCHEME);\n    }\n\n    /**\n     * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates.\n     * @return {RegisterAppInterface}\n     */\n    setNightColorScheme (scheme) {\n        this.validateType(TemplateColorScheme, scheme);\n        this.setParameter(RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME, scheme);\n        return this;\n    }\n\n    /**\n     * @return {TemplateColorScheme}\n     */\n    getNightColorScheme () {\n        return this.getObject(TemplateColorScheme, RegisterAppInterface.KEY_NIGHT_COLOR_SCHEME);\n    }\n}\n\nRegisterAppInterface.KEY_SDL_MSG_VERSION = 'syncMsgVersion';\nRegisterAppInterface.KEY_APP_NAME = 'appName';\nRegisterAppInterface.KEY_TTS_NAME = 'ttsName';\nRegisterAppInterface.KEY_NGN_MEDIA_SCREEN_APP_NAME = 'ngnMediaScreenAppName';\nRegisterAppInterface.KEY_VR_SYNONYMS = 'vrSynonyms';\nRegisterAppInterface.KEY_IS_MEDIA_APPLICATION = 'isMediaApplication';\nRegisterAppInterface.KEY_LANGUAGE_DESIRED = 'languageDesired';\nRegisterAppInterface.KEY_HMI_DISPLAY_LANGUAGE_DESIRED = 'hmiDisplayLanguageDesired';\nRegisterAppInterface.KEY_APP_HMI_TYPE = 'appHMIType';\nRegisterAppInterface.KEY_HASH_ID = 'hashID';\nRegisterAppInterface.KEY_DEVICE_INFO = 'deviceInfo';\nRegisterAppInterface.KEY_APP_ID = 'appID';\nRegisterAppInterface.KEY_FULL_APP_ID = 'fullAppID';\nRegisterAppInterface.KEY_APP_INFO = 'appInfo';\nRegisterAppInterface.KEY_DAY_COLOR_SCHEME = 'dayColorScheme';\nRegisterAppInterface.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme';\nRegisterAppInterface.APP_ID_MAX_LENGTH = 10;\n\nexport { RegisterAppInterface };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} Result\n * @property {Object} _MAP\n */\nclass Result extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The request succeeded\n     * @return {String}\n     */\n    static get SUCCESS () {\n        return Result._MAP.SUCCESS;\n    }\n\n    /**\n     * The request is not supported by the headunit\n     * @return {String}\n     */\n    static get UNSUPPORTED_REQUEST () {\n        return Result._MAP.UNSUPPORTED_REQUEST;\n    }\n\n    /**\n     * A button that was requested for subscription is not supported under the current system.\n     * @return {String}\n     */\n    static get UNSUPPORTED_RESOURCE () {\n        return Result._MAP.UNSUPPORTED_RESOURCE;\n    }\n\n    /**\n     * RPC is not authorized in local policy table.\n     * @return {String}\n     */\n    static get DISALLOWED () {\n        return Result._MAP.DISALLOWED;\n    }\n\n    /**\n     * The requested command was rejected, e.g. because mobile app is in background and cannot perform any HMI\n     * commands. Or an HMI command (e.g. Speak) is rejected because a higher priority HMI command (e.g. Alert) is\n     * playing.\n     * @return {String}\n     */\n    static get REJECTED () {\n        return Result._MAP.REJECTED;\n    }\n\n    /**\n     * A command was aborted, for example due to user interaction (e.g. user pressed button). Or an HMI command (e.g.\n     * Speak) is aborted because a higher priority HMI command (e.g. Alert) was requested.\n     * @return {String}\n     */\n    static get ABORTED () {\n        return Result._MAP.ABORTED;\n    }\n\n    /**\n     * A command was ignored, because the intended result is already in effect. For example, SetMediaClockTimer was\n     * used to pause the media clock although the clock is paused already. NOTE: potentially replaces\n     * SUBSCRIBED_ALREADY\n     * @return {String}\n     */\n    static get IGNORED () {\n        return Result._MAP.IGNORED;\n    }\n\n    /**\n     * The user interrupted the RPC (e.g. PerformAudioPassThru) and indicated to start over. Note, the app must issue\n     * the new RPC.\n     * @return {String}\n     */\n    static get RETRY () {\n        return Result._MAP.RETRY;\n    }\n\n    /**\n     * The data may not be changed, because it is currently in use. For example when trying to delete a command set\n     * that is currently involved in an interaction.\n     * @return {String}\n     */\n    static get IN_USE () {\n        return Result._MAP.IN_USE;\n    }\n\n    /**\n     * The requested vehicle data is not available on this vehicle or is not published.\n     * @return {String}\n     */\n    static get VEHICLE_DATA_NOT_AVAILABLE () {\n        return Result._MAP.VEHICLE_DATA_NOT_AVAILABLE;\n    }\n\n    /**\n     * Overlay reached the maximum timeout and closed.\n     * @return {String}\n     */\n    static get TIMED_OUT () {\n        return Result._MAP.TIMED_OUT;\n    }\n\n    /**\n     * The data sent is invalid. For example: Invalid Json syntax Parameters out of bounds (number or enum range)\n     * Mandatory parameters not provided Parameter provided with wrong type Invalid characters Empty string\n     * @return {String}\n     */\n    static get INVALID_DATA () {\n        return Result._MAP.INVALID_DATA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CHAR_LIMIT_EXCEEDED () {\n        return Result._MAP.CHAR_LIMIT_EXCEEDED;\n    }\n\n    /**\n     * One of the provided IDs is not valid. For example This applies to CorrelationID, SubscriptionID, CommandID,\n     * MenuID, etc.\n     * @return {String}\n     */\n    static get INVALID_ID () {\n        return Result._MAP.INVALID_ID;\n    }\n\n    /**\n     * There was a conflict with an registered name (application or menu item) or vr command\n     * @return {String}\n     */\n    static get DUPLICATE_NAME () {\n        return Result._MAP.DUPLICATE_NAME;\n    }\n\n    /**\n     * An command can not be executed because no application has been registered with RegisterApplication.\n     * @return {String}\n     */\n    static get APPLICATION_NOT_REGISTERED () {\n        return Result._MAP.APPLICATION_NOT_REGISTERED;\n    }\n\n    /**\n     * The requested language is currently not supported. Might be because of a mismatch of the currently active\n     * language on the headunit and the requested language\n     * @return {String}\n     */\n    static get WRONG_LANGUAGE () {\n        return Result._MAP.WRONG_LANGUAGE;\n    }\n\n    /**\n     * The system could not process the request because the necessary memory couldn't be allocated\n     * @return {String}\n     */\n    static get OUT_OF_MEMORY () {\n        return Result._MAP.OUT_OF_MEMORY;\n    }\n\n    /**\n     * There are too many requests pending (means, that the response has not been delivered, yet).There may be a\n     * maximum of 1000 pending requests at a time.\n     * @return {String}\n     */\n    static get TOO_MANY_PENDING_REQUESTS () {\n        return Result._MAP.TOO_MANY_PENDING_REQUESTS;\n    }\n\n    /**\n     * There are already too many registered applications\n     * @return {String}\n     */\n    static get TOO_MANY_APPLICATIONS () {\n        return Result._MAP.TOO_MANY_APPLICATIONS;\n    }\n\n    /**\n     * RegisterApplication has been called again, after a RegisterApplication was successful before.\n     * @return {String}\n     */\n    static get APPLICATION_REGISTERED_ALREADY () {\n        return Result._MAP.APPLICATION_REGISTERED_ALREADY;\n    }\n\n    /**\n     * The RPC (e.g. SubscribeVehicleData) executed successfully but one or more items have a warning or failure.\n     * @return {String}\n     */\n    static get WARNINGS () {\n        return Result._MAP.WARNINGS;\n    }\n\n    /**\n     * Provided data is valid but something went wrong in the lower layers.\n     * @return {String}\n     */\n    static get GENERIC_ERROR () {\n        return Result._MAP.GENERIC_ERROR;\n    }\n\n    /**\n     * RPC is included in a functional group explicitly blocked by the user.\n     * @return {String}\n     */\n    static get USER_DISALLOWED () {\n        return Result._MAP.USER_DISALLOWED;\n    }\n\n    /**\n     * The RPC (e.g. ReadDID) executed successfully but the data exceeded the platform maximum threshold and thus,\n     * only part of the data is available.\n     * @return {String}\n     */\n    static get TRUNCATED_DATA () {\n        return Result._MAP.TRUNCATED_DATA;\n    }\n\n    /**\n     * Sync doesn't support the protocol that is requested by the mobile application\n     * @return {String}\n     */\n    static get UNSUPPORTED_VERSION () {\n        return Result._MAP.UNSUPPORTED_VERSION;\n    }\n\n    /**\n     * The user has turned off access to vehicle data, and it is globally unavailable to mobile applications.\n     * @return {String}\n     */\n    static get VEHICLE_DATA_NOT_ALLOWED () {\n        return Result._MAP.VEHICLE_DATA_NOT_ALLOWED;\n    }\n\n    /**\n     * A specified file could not be found on the headunit.\n     * @return {String}\n     */\n    static get FILE_NOT_FOUND () {\n        return Result._MAP.FILE_NOT_FOUND;\n    }\n\n    /**\n     * User selected to Cancel Route.\n     * @return {String}\n     */\n    static get CANCEL_ROUTE () {\n        return Result._MAP.CANCEL_ROUTE;\n    }\n\n    /**\n     * The RPC (e.g. Slider) executed successfully and the user elected to save the current position / value.\n     * @return {String}\n     */\n    static get SAVED () {\n        return Result._MAP.SAVED;\n    }\n\n    /**\n     * The certificate provided during authentication is invalid.\n     * @return {String}\n     */\n    static get INVALID_CERT () {\n        return Result._MAP.INVALID_CERT;\n    }\n\n    /**\n     * The certificate provided during authentication is expired.\n     * @return {String}\n     */\n    static get EXPIRED_CERT () {\n        return Result._MAP.EXPIRED_CERT;\n    }\n\n    /**\n     * The provided hash ID does not match the hash of the current set of registered data or the core could not resume\n     * the previous data.\n     * @return {String}\n     */\n    static get RESUME_FAILED () {\n        return Result._MAP.RESUME_FAILED;\n    }\n\n    /**\n     * The requested information is currently not available. This is different than UNSUPPORTED_RESOURCE because it\n     * implies the data is at some point available.\n     * @return {String}\n     */\n    static get DATA_NOT_AVAILABLE () {\n        return Result._MAP.DATA_NOT_AVAILABLE;\n    }\n\n    /**\n     * The value being set is read only\n     * @return {String}\n     */\n    static get READ_ONLY () {\n        return Result._MAP.READ_ONLY;\n    }\n\n    /**\n     * The data sent failed to pass CRC check in receiver end\n     * @return {String}\n     */\n    static get CORRUPTED_DATA () {\n        return Result._MAP.CORRUPTED_DATA;\n    }\n\n    /**\n     * SDL receives an un-encrypted RPC request that needs protection.\n     * @return {String}\n     */\n    static get ENCRYPTION_NEEDED () {\n        return Result._MAP.ENCRYPTION_NEEDED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return Result._valueForKey(key, Result._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return Result._keyForValue(value, Result._MAP);\n    }\n}\n\nResult._MAP = Object.freeze({\n    'SUCCESS': 'SUCCESS',\n    'UNSUPPORTED_REQUEST': 'UNSUPPORTED_REQUEST',\n    'UNSUPPORTED_RESOURCE': 'UNSUPPORTED_RESOURCE',\n    'DISALLOWED': 'DISALLOWED',\n    'REJECTED': 'REJECTED',\n    'ABORTED': 'ABORTED',\n    'IGNORED': 'IGNORED',\n    'RETRY': 'RETRY',\n    'IN_USE': 'IN_USE',\n    'VEHICLE_DATA_NOT_AVAILABLE': 'VEHICLE_DATA_NOT_AVAILABLE',\n    'TIMED_OUT': 'TIMED_OUT',\n    'INVALID_DATA': 'INVALID_DATA',\n    'CHAR_LIMIT_EXCEEDED': 'CHAR_LIMIT_EXCEEDED',\n    'INVALID_ID': 'INVALID_ID',\n    'DUPLICATE_NAME': 'DUPLICATE_NAME',\n    'APPLICATION_NOT_REGISTERED': 'APPLICATION_NOT_REGISTERED',\n    'WRONG_LANGUAGE': 'WRONG_LANGUAGE',\n    'OUT_OF_MEMORY': 'OUT_OF_MEMORY',\n    'TOO_MANY_PENDING_REQUESTS': 'TOO_MANY_PENDING_REQUESTS',\n    'TOO_MANY_APPLICATIONS': 'TOO_MANY_APPLICATIONS',\n    'APPLICATION_REGISTERED_ALREADY': 'APPLICATION_REGISTERED_ALREADY',\n    'WARNINGS': 'WARNINGS',\n    'GENERIC_ERROR': 'GENERIC_ERROR',\n    'USER_DISALLOWED': 'USER_DISALLOWED',\n    'TRUNCATED_DATA': 'TRUNCATED_DATA',\n    'UNSUPPORTED_VERSION': 'UNSUPPORTED_VERSION',\n    'VEHICLE_DATA_NOT_ALLOWED': 'VEHICLE_DATA_NOT_ALLOWED',\n    'FILE_NOT_FOUND': 'FILE_NOT_FOUND',\n    'CANCEL_ROUTE': 'CANCEL_ROUTE',\n    'SAVED': 'SAVED',\n    'INVALID_CERT': 'INVALID_CERT',\n    'EXPIRED_CERT': 'EXPIRED_CERT',\n    'RESUME_FAILED': 'RESUME_FAILED',\n    'DATA_NOT_AVAILABLE': 'DATA_NOT_AVAILABLE',\n    'READ_ONLY': 'READ_ONLY',\n    'CORRUPTED_DATA': 'CORRUPTED_DATA',\n    'ENCRYPTION_NEEDED': 'ENCRYPTION_NEEDED',\n});\n\nexport { Result };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcMessage } from './RpcMessage.js';\nimport { RpcType } from './enums/RpcType.js';\nimport { Result } from './enums/Result.js';\n\nclass RpcResponse extends RpcMessage {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setRPCType(RpcType.RESPONSE);\n    }\n\n    /**\n    * @return {Boolean}\n    */\n    getSuccess () {\n        return this.getParameter(RpcResponse.KEY_SUCCESS);\n    }\n\n    /**\n    * @return {RpcResponse}\n    */\n    setSuccess (success) {\n        this.setParameter(RpcResponse.KEY_SUCCESS, success);\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    getInfo () {\n        return this.getParameter(RpcResponse.KEY_INFO);\n    }\n\n    /**\n    * @return {RpcResponse}\n    */\n    setInfo (info) {\n        this.setParameter(RpcResponse.KEY_INFO, info);\n        return this;\n    }\n\n    /**\n    * @return {Result}\n    */\n    getResultCode () {\n        return this.getObject(Result, RpcResponse.KEY_RESULT_CODE);\n    }\n\n    /**\n    * @return {RpcResponse}\n    */\n    setResultCode (resultCode) {\n        this.validateType(Result, resultCode);\n\n        this.setParameter(RpcResponse.KEY_RESULT_CODE, resultCode);\n        return this;\n    }\n}\n\nRpcResponse.KEY_SUCCESS     = 'success';\nRpcResponse.KEY_INFO        = 'info';\nRpcResponse.KEY_RESULT_CODE = 'resultCode';\n\nexport { RpcResponse };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass RpcListener {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this._onRpcMessage = null;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {RpcListener}\n     */\n    setOnRpcMessage (func) {\n        this._onRpcMessage = func;\n\n        return this;\n    }\n\n    /**\n     *\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessage (rpcMessage) {\n        if (typeof this._onRpcMessage === 'function') {\n            this._onRpcMessage(rpcMessage);\n        }\n    }\n}\n\nexport { RpcListener };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} SdlProtocolListener\n * @property {function} setOnRpcMessageReceived\n * @property {function} onRpcMessageReceived\n * @property {function} setOnProtocolSessionStarted\n * @property {function} onProtocolSessionStarted\n * @property {function} setOnProtocolSessionEnded\n * @property {function} onProtocolSessionEnded\n * @property {function} setOnProtocolSessionEndedNACKed\n * @property {function} onProtocolSessionEndedNACKed\n * @property {function} setGetSessionId\n * @property {function} getSessionId\n */\nclass SdlProtocolListener {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this._onRpcMessageReceived = null;\n        this._onProtocolSessionStarted = null;\n        this._onProtocolSessionEnded = null;\n        this._onProtocolSessionEndedNACKed = null;\n        this._getSessionId = null;\n        this._onTransportConnected = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnTransportConnected (listener) {\n        this._onTransportConnected = listener;\n        return this;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnRpcMessageReceived (listener) {\n        this._onRpcMessageReceived = listener;\n        return this;\n    }\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessageReceived (rpcMessage) {\n        if (typeof this._onRpcMessageReceived === 'function') {\n            this._onRpcMessageReceived(rpcMessage);\n        }\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionStarted (listener) {\n        this._onProtocolSessionStarted = listener;\n        return this;\n    }\n\n\n    onTransportConnected () {\n        if (typeof this._onTransportConnected === 'function') {\n            this._onTransportConnected();\n        }\n    }\n\n    /**\n     * Invoke the onProtocolSessionStarted listener with the event data\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {Number} version\n     * @param {String} correlationId\n     * @param {Number} hashId\n     * @param {Boolean} isEncrypted\n     */\n    onProtocolSessionStarted (serviceType, sessionId, version, correlationId, hashId, isEncrypted) {\n        if (typeof this._onProtocolSessionStarted === 'function') {\n            this._onProtocolSessionStarted(serviceType, sessionId, version, correlationId, hashId, isEncrypted);\n        }\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEnded (listener) {\n        this._onProtocolSessionEnded = listener;\n        return this;\n    }\n\n    /**\n     * Invoke the onProtocolSessionEnded listener with the event data\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {String} correlationId\n     */\n    onProtocolSessionEnded (serviceType, sessionId, correlationId) {\n        if (typeof this._onProtocolSessionEnded === 'function') {\n            this._onProtocolSessionEnded(serviceType, sessionId, correlationId);\n        }\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEndedNACKed (listener) {\n        this._onProtocolSessionEndedNACKed = listener;\n        return this;\n    }\n\n    /**\n     * Invoke the onProtocolSessionEndedNACKed listener with the event data\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {String} correlationId\n     */\n    onProtocolSessionEndedNACKed (serviceType, sessionId, correlationId) {\n        if (typeof this._onProtocolSessionEndedNACKed === 'function') {\n            this._onProtocolSessionEndedNACKed(serviceType, sessionId, correlationId);\n        }\n    }\n\n    /**\n     * @param {function} getter\n     */\n    setGetSessionId (getter) {\n        this._getSessionId = getter;\n        return this;\n    }\n\n    /**\n     * Invoke the getSessionId getter\n     * @returns {Number} sessionId\n     */\n    getSessionId () {\n        if (typeof this._getSessionId === 'function') {\n            return this._getSessionId();\n        }\n    }\n\n\n    /**\n     * Sets the getDesiredVideoParams getter\n     * @param {function} getter\n     */\n    setGetDesiredVideoParams (getter) {\n        this._getDesiredVideoParams = getter;\n        return this;\n    }\n\n    /**\n     * Invoke the getDesiredVideoParams getter\n     * @returns {VideoStreamingParameters}\n     */\n    getDesiredVideoParams () {\n        if (typeof this._getDesiredVideoParams === 'function') {\n            return this._getDesiredVideoParams();\n        }\n    }\n\n    /**\n     * Sets the setSetAcceptedVideoParams setter\n     * @param {function} setter\n     */\n    setSetAcceptedVideoParams (setter) {\n        this._setAcceptedVideoParams = setter;\n        return this;\n    }\n\n\n    /**\n     * Invoke the setAcceptedVideoParams setter\n     * @param {VideoStreamingParameters} params\n     */\n    setAcceptedVideoParams (params) {\n        if (typeof this._setAcceptedVideoParams === 'function') {\n            this._setAcceptedVideoParams(params);\n        }\n        return this;\n    }\n}\n\nexport { SdlProtocolListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} FrameType\n * @property {Object} _MAP\n */\nclass FrameType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CONTROL () {\n        return FrameType._MAP.CONTROL;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get FIRST () {\n        return FrameType._MAP.FIRST;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CONSECUTIVE () {\n        return FrameType._MAP.CONSECUTIVE;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get SINGLE () {\n        return FrameType._MAP.SINGLE;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return FrameType._valueForKey(key, FrameType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return FrameType._keyForValue(value, FrameType._MAP);\n    }\n}\n\nFrameType._MAP = Object.freeze({\n    'CONTROL': 0x00,\n    'FIRST': 0x02,\n    'CONSECUTIVE': 0x03,\n    'SINGLE': 0x01,\n});\n\nexport { FrameType };\n","exports[\"bson\"] =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 2);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\nvar g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\n} catch(e) {\n\t// This works if the window reference is available\n\tif(typeof window === \"object\")\n\t\tg = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n\n\nvar base64 = __webpack_require__(3)\nvar ieee754 = __webpack_require__(4)\nvar isArray = __webpack_require__(5)\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, Buffer) {(function (global, factory) {\n\t true ? factory(exports, __webpack_require__(6), __webpack_require__(1)) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'long', 'buffer'], factory) :\n\t(factory((global.BSON = {}),global.long,global.Buffer));\n}(this, (function (exports,long,buffer) { 'use strict';\n\n\tlong = long && long.hasOwnProperty('default') ? long['default'] : long;\n\tbuffer = buffer && buffer.hasOwnProperty('default') ? buffer['default'] : buffer;\n\n\tvar commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\n\tfunction createCommonjsModule(fn, module) {\n\t\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n\t}\n\n\tfunction getCjsExportFromNamespace (n) {\n\t\treturn n && n.default || n;\n\t}\n\n\tvar map = createCommonjsModule(function (module) {\n\n\t  if (typeof commonjsGlobal.Map !== 'undefined') {\n\t    module.exports = commonjsGlobal.Map;\n\t    module.exports.Map = commonjsGlobal.Map;\n\t  } else {\n\t    // We will return a polyfill\n\t    var Map = function Map(array) {\n\t      this._keys = [];\n\t      this._values = {};\n\n\t      for (var i = 0; i < array.length; i++) {\n\t        if (array[i] == null) continue; // skip null and undefined\n\n\t        var entry = array[i];\n\t        var key = entry[0];\n\t        var value = entry[1]; // Add the key to the list of keys in order\n\n\t        this._keys.push(key); // Add the key and value to the values dictionary with a point\n\t        // to the location in the ordered keys list\n\n\n\t        this._values[key] = {\n\t          v: value,\n\t          i: this._keys.length - 1\n\t        };\n\t      }\n\t    };\n\n\t    Map.prototype.clear = function () {\n\t      this._keys = [];\n\t      this._values = {};\n\t    };\n\n\t    Map.prototype.delete = function (key) {\n\t      var value = this._values[key];\n\t      if (value == null) return false; // Delete entry\n\n\t      delete this._values[key]; // Remove the key from the ordered keys list\n\n\t      this._keys.splice(value.i, 1);\n\n\t      return true;\n\t    };\n\n\t    Map.prototype.entries = function () {\n\t      var self = this;\n\t      var index = 0;\n\t      return {\n\t        next: function next() {\n\t          var key = self._keys[index++];\n\t          return {\n\t            value: key !== undefined ? [key, self._values[key].v] : undefined,\n\t            done: key !== undefined ? false : true\n\t          };\n\t        }\n\t      };\n\t    };\n\n\t    Map.prototype.forEach = function (callback, self) {\n\t      self = self || this;\n\n\t      for (var i = 0; i < this._keys.length; i++) {\n\t        var key = this._keys[i]; // Call the forEach callback\n\n\t        callback.call(self, this._values[key].v, key, self);\n\t      }\n\t    };\n\n\t    Map.prototype.get = function (key) {\n\t      return this._values[key] ? this._values[key].v : undefined;\n\t    };\n\n\t    Map.prototype.has = function (key) {\n\t      return this._values[key] != null;\n\t    };\n\n\t    Map.prototype.keys = function () {\n\t      var self = this;\n\t      var index = 0;\n\t      return {\n\t        next: function next() {\n\t          var key = self._keys[index++];\n\t          return {\n\t            value: key !== undefined ? key : undefined,\n\t            done: key !== undefined ? false : true\n\t          };\n\t        }\n\t      };\n\t    };\n\n\t    Map.prototype.set = function (key, value) {\n\t      if (this._values[key]) {\n\t        this._values[key].v = value;\n\t        return this;\n\t      } // Add the key to the list of keys in order\n\n\n\t      this._keys.push(key); // Add the key and value to the values dictionary with a point\n\t      // to the location in the ordered keys list\n\n\n\t      this._values[key] = {\n\t        v: value,\n\t        i: this._keys.length - 1\n\t      };\n\t      return this;\n\t    };\n\n\t    Map.prototype.values = function () {\n\t      var self = this;\n\t      var index = 0;\n\t      return {\n\t        next: function next() {\n\t          var key = self._keys[index++];\n\t          return {\n\t            value: key !== undefined ? self._values[key].v : undefined,\n\t            done: key !== undefined ? false : true\n\t          };\n\t        }\n\t      };\n\t    }; // Last ismaster\n\n\n\t    Object.defineProperty(Map.prototype, 'size', {\n\t      enumerable: true,\n\t      get: function get() {\n\t        return this._keys.length;\n\t      }\n\t    });\n\t    module.exports = Map;\n\t  }\n\t});\n\tvar map_1 = map.Map;\n\n\t/**\n\t * @ignore\n\t */\n\n\n\tlong.prototype.toExtendedJSON = function (options) {\n\t  if (options && options.relaxed) return this.toNumber();\n\t  return {\n\t    $numberLong: this.toString()\n\t  };\n\t};\n\t/**\n\t * @ignore\n\t */\n\n\n\tlong.fromExtendedJSON = function (doc, options) {\n\t  var result = long.fromString(doc.$numberLong);\n\t  return options && options.relaxed ? result.toNumber() : result;\n\t};\n\n\tObject.defineProperty(long.prototype, '_bsontype', {\n\t  value: 'Long'\n\t});\n\tvar long_1 = long;\n\n\t/**\n\t * A class representation of the BSON Double type.\n\t */\n\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n\tvar Double =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Double type\n\t   *\n\t   * @param {number} value the number we want to represent as a double.\n\t   * @return {Double}\n\t   */\n\t  function Double(value) {\n\t    _classCallCheck(this, Double);\n\n\t    this.value = value;\n\t  }\n\t  /**\n\t   * Access the number value.\n\t   *\n\t   * @method\n\t   * @return {number} returns the wrapped double number.\n\t   */\n\n\n\t  _createClass(Double, [{\n\t    key: \"valueOf\",\n\t    value: function valueOf() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON(options) {\n\t      if (options && options.relaxed && isFinite(this.value)) return this.value;\n\t      return {\n\t        $numberDouble: this.value.toString()\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc, options) {\n\t      return options && options.relaxed ? parseFloat(doc.$numberDouble) : new Double(parseFloat(doc.$numberDouble));\n\t    }\n\t  }]);\n\n\t  return Double;\n\t}();\n\n\tObject.defineProperty(Double.prototype, '_bsontype', {\n\t  value: 'Double'\n\t});\n\tvar double_1 = Double;\n\n\tfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n\tfunction _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }\n\n\tfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\n\tfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\n\tfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\n\tfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\t/**\n\t * @class\n\t * @param {number} low  the low (signed) 32 bits of the Timestamp.\n\t * @param {number} high the high (signed) 32 bits of the Timestamp.\n\t * @return {Timestamp}\n\t */\n\n\n\tvar Timestamp =\n\t/*#__PURE__*/\n\tfunction (_Long) {\n\t  _inherits(Timestamp, _Long);\n\n\t  function Timestamp(low, high) {\n\t    var _this;\n\n\t    _classCallCheck$1(this, Timestamp);\n\n\t    if (long_1.isLong(low)) {\n\t      _this = _possibleConstructorReturn(this, _getPrototypeOf(Timestamp).call(this, low.low, low.high));\n\t    } else {\n\t      _this = _possibleConstructorReturn(this, _getPrototypeOf(Timestamp).call(this, low, high));\n\t    }\n\n\t    return _possibleConstructorReturn(_this);\n\t  }\n\t  /**\n\t   * Return the JSON value.\n\t   *\n\t   * @method\n\t   * @return {String} the JSON representation.\n\t   */\n\n\n\t  _createClass$1(Timestamp, [{\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return {\n\t        $timestamp: this.toString()\n\t      };\n\t    }\n\t    /**\n\t     * Returns a Timestamp represented by the given (32-bit) integer value.\n\t     *\n\t     * @method\n\t     * @param {number} value the 32-bit integer in question.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\n\t    /**\n\t     * @ignore\n\t     */\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $timestamp: {\n\t          t: this.high,\n\t          i: this.low\n\t        }\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromInt\",\n\t    value: function fromInt(value) {\n\t      return new Timestamp(long_1.fromInt(value));\n\t    }\n\t    /**\n\t     * Returns a Timestamp representing the given number value, provided that it is a finite number. Otherwise, zero is returned.\n\t     *\n\t     * @method\n\t     * @param {number} value the number in question.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"fromNumber\",\n\t    value: function fromNumber(value) {\n\t      return new Timestamp(long_1.fromNumber(value));\n\t    }\n\t    /**\n\t     * Returns a Timestamp for the given high and low bits. Each is assumed to use 32 bits.\n\t     *\n\t     * @method\n\t     * @param {number} lowBits the low 32-bits.\n\t     * @param {number} highBits the high 32-bits.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"fromBits\",\n\t    value: function fromBits(lowBits, highBits) {\n\t      return new Timestamp(lowBits, highBits);\n\t    }\n\t    /**\n\t     * Returns a Timestamp from the given string, optionally using the given radix.\n\t     *\n\t     * @method\n\t     * @param {String} str the textual representation of the Timestamp.\n\t     * @param {number} [opt_radix] the radix in which the text is written.\n\t     * @return {Timestamp} the timestamp.\n\t     */\n\n\t  }, {\n\t    key: \"fromString\",\n\t    value: function fromString(str, opt_radix) {\n\t      return new Timestamp(long_1.fromString(str, opt_radix));\n\t    }\n\t  }, {\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new Timestamp(doc.$timestamp.i, doc.$timestamp.t);\n\t    }\n\t  }]);\n\n\t  return Timestamp;\n\t}(long_1);\n\n\tObject.defineProperty(Timestamp.prototype, '_bsontype', {\n\t  value: 'Timestamp'\n\t});\n\tvar timestamp = Timestamp;\n\n\tvar empty = {};\n\n\tvar empty$1 = /*#__PURE__*/Object.freeze({\n\t\tdefault: empty\n\t});\n\n\tvar require$$0 = getCjsExportFromNamespace(empty$1);\n\n\t/* global window */\n\n\t/**\n\t * Normalizes our expected stringified form of a function across versions of node\n\t * @param {Function} fn The function to stringify\n\t */\n\n\n\tfunction normalizedFunctionString(fn) {\n\t  return fn.toString().replace('function(', 'function (');\n\t}\n\n\tfunction insecureRandomBytes(size) {\n\t  var result = new Uint8Array(size);\n\n\t  for (var i = 0; i < size; ++i) {\n\t    result[i] = Math.floor(Math.random() * 256);\n\t  }\n\n\t  return result;\n\t}\n\n\tvar randomBytes = insecureRandomBytes;\n\n\tif (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {\n\t  randomBytes = function randomBytes(size) {\n\t    return window.crypto.getRandomValues(new Uint8Array(size));\n\t  };\n\t} else {\n\t  try {\n\t    randomBytes = require$$0.randomBytes;\n\t  } catch (e) {} // keep the fallback\n\t  // NOTE: in transpiled cases the above require might return null/undefined\n\n\n\t  if (randomBytes == null) {\n\t    randomBytes = insecureRandomBytes;\n\t  }\n\t}\n\n\tvar utils = {\n\t  normalizedFunctionString: normalizedFunctionString,\n\t  randomBytes: randomBytes\n\t};\n\n\t// shim for using process in browser\n\t// based off https://github.com/defunctzombie/node-process/blob/master/browser.js\n\tfunction defaultSetTimout() {\n\t  throw new Error('setTimeout has not been defined');\n\t}\n\n\tfunction defaultClearTimeout() {\n\t  throw new Error('clearTimeout has not been defined');\n\t}\n\n\tvar cachedSetTimeout = defaultSetTimout;\n\tvar cachedClearTimeout = defaultClearTimeout;\n\n\tif (typeof global.setTimeout === 'function') {\n\t  cachedSetTimeout = setTimeout;\n\t}\n\n\tif (typeof global.clearTimeout === 'function') {\n\t  cachedClearTimeout = clearTimeout;\n\t}\n\n\tfunction runTimeout(fun) {\n\t  if (cachedSetTimeout === setTimeout) {\n\t    //normal enviroments in sane situations\n\t    return setTimeout(fun, 0);\n\t  } // if setTimeout wasn't available but was latter defined\n\n\n\t  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n\t    cachedSetTimeout = setTimeout;\n\t    return setTimeout(fun, 0);\n\t  }\n\n\t  try {\n\t    // when when somebody has screwed with setTimeout but no I.E. maddness\n\t    return cachedSetTimeout(fun, 0);\n\t  } catch (e) {\n\t    try {\n\t      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t      return cachedSetTimeout.call(null, fun, 0);\n\t    } catch (e) {\n\t      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n\t      return cachedSetTimeout.call(this, fun, 0);\n\t    }\n\t  }\n\t}\n\n\tfunction runClearTimeout(marker) {\n\t  if (cachedClearTimeout === clearTimeout) {\n\t    //normal enviroments in sane situations\n\t    return clearTimeout(marker);\n\t  } // if clearTimeout wasn't available but was latter defined\n\n\n\t  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n\t    cachedClearTimeout = clearTimeout;\n\t    return clearTimeout(marker);\n\t  }\n\n\t  try {\n\t    // when when somebody has screwed with setTimeout but no I.E. maddness\n\t    return cachedClearTimeout(marker);\n\t  } catch (e) {\n\t    try {\n\t      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n\t      return cachedClearTimeout.call(null, marker);\n\t    } catch (e) {\n\t      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n\t      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n\t      return cachedClearTimeout.call(this, marker);\n\t    }\n\t  }\n\t}\n\n\tvar queue = [];\n\tvar draining = false;\n\tvar currentQueue;\n\tvar queueIndex = -1;\n\n\tfunction cleanUpNextTick() {\n\t  if (!draining || !currentQueue) {\n\t    return;\n\t  }\n\n\t  draining = false;\n\n\t  if (currentQueue.length) {\n\t    queue = currentQueue.concat(queue);\n\t  } else {\n\t    queueIndex = -1;\n\t  }\n\n\t  if (queue.length) {\n\t    drainQueue();\n\t  }\n\t}\n\n\tfunction drainQueue() {\n\t  if (draining) {\n\t    return;\n\t  }\n\n\t  var timeout = runTimeout(cleanUpNextTick);\n\t  draining = true;\n\t  var len = queue.length;\n\n\t  while (len) {\n\t    currentQueue = queue;\n\t    queue = [];\n\n\t    while (++queueIndex < len) {\n\t      if (currentQueue) {\n\t        currentQueue[queueIndex].run();\n\t      }\n\t    }\n\n\t    queueIndex = -1;\n\t    len = queue.length;\n\t  }\n\n\t  currentQueue = null;\n\t  draining = false;\n\t  runClearTimeout(timeout);\n\t}\n\n\tfunction nextTick(fun) {\n\t  var args = new Array(arguments.length - 1);\n\n\t  if (arguments.length > 1) {\n\t    for (var i = 1; i < arguments.length; i++) {\n\t      args[i - 1] = arguments[i];\n\t    }\n\t  }\n\n\t  queue.push(new Item(fun, args));\n\n\t  if (queue.length === 1 && !draining) {\n\t    runTimeout(drainQueue);\n\t  }\n\t} // v8 likes predictible objects\n\n\tfunction Item(fun, array) {\n\t  this.fun = fun;\n\t  this.array = array;\n\t}\n\n\tItem.prototype.run = function () {\n\t  this.fun.apply(null, this.array);\n\t};\n\n\tvar title = 'browser';\n\tvar platform = 'browser';\n\tvar browser = true;\n\tvar env = {};\n\tvar argv = [];\n\tvar version = ''; // empty string to avoid regexp issues\n\n\tvar versions = {};\n\tvar release = {};\n\tvar config = {};\n\n\tfunction noop() {}\n\n\tvar on = noop;\n\tvar addListener = noop;\n\tvar once = noop;\n\tvar off = noop;\n\tvar removeListener = noop;\n\tvar removeAllListeners = noop;\n\tvar emit = noop;\n\tfunction binding(name) {\n\t  throw new Error('process.binding is not supported');\n\t}\n\tfunction cwd() {\n\t  return '/';\n\t}\n\tfunction chdir(dir) {\n\t  throw new Error('process.chdir is not supported');\n\t}\n\tfunction umask() {\n\t  return 0;\n\t} // from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\n\n\tvar performance = global.performance || {};\n\n\tvar performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function () {\n\t  return new Date().getTime();\n\t}; // generate timestamp or delta\n\t// see http://nodejs.org/api/process.html#process_process_hrtime\n\n\n\tfunction hrtime(previousTimestamp) {\n\t  var clocktime = performanceNow.call(performance) * 1e-3;\n\t  var seconds = Math.floor(clocktime);\n\t  var nanoseconds = Math.floor(clocktime % 1 * 1e9);\n\n\t  if (previousTimestamp) {\n\t    seconds = seconds - previousTimestamp[0];\n\t    nanoseconds = nanoseconds - previousTimestamp[1];\n\n\t    if (nanoseconds < 0) {\n\t      seconds--;\n\t      nanoseconds += 1e9;\n\t    }\n\t  }\n\n\t  return [seconds, nanoseconds];\n\t}\n\tvar startTime = new Date();\n\tfunction uptime() {\n\t  var currentTime = new Date();\n\t  var dif = currentTime - startTime;\n\t  return dif / 1000;\n\t}\n\tvar process = {\n\t  nextTick: nextTick,\n\t  title: title,\n\t  browser: browser,\n\t  env: env,\n\t  argv: argv,\n\t  version: version,\n\t  versions: versions,\n\t  on: on,\n\t  addListener: addListener,\n\t  once: once,\n\t  off: off,\n\t  removeListener: removeListener,\n\t  removeAllListeners: removeAllListeners,\n\t  emit: emit,\n\t  binding: binding,\n\t  cwd: cwd,\n\t  chdir: chdir,\n\t  umask: umask,\n\t  hrtime: hrtime,\n\t  platform: platform,\n\t  release: release,\n\t  config: config,\n\t  uptime: uptime\n\t};\n\n\tvar inherits;\n\n\tif (typeof Object.create === 'function') {\n\t  inherits = function inherits(ctor, superCtor) {\n\t    // implementation from standard node.js 'util' module\n\t    ctor.super_ = superCtor;\n\t    ctor.prototype = Object.create(superCtor.prototype, {\n\t      constructor: {\n\t        value: ctor,\n\t        enumerable: false,\n\t        writable: true,\n\t        configurable: true\n\t      }\n\t    });\n\t  };\n\t} else {\n\t  inherits = function inherits(ctor, superCtor) {\n\t    ctor.super_ = superCtor;\n\n\t    var TempCtor = function TempCtor() {};\n\n\t    TempCtor.prototype = superCtor.prototype;\n\t    ctor.prototype = new TempCtor();\n\t    ctor.prototype.constructor = ctor;\n\t  };\n\t}\n\n\tvar inherits$1 = inherits;\n\n\tfunction _typeof$1(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$1(obj); }\n\tvar formatRegExp = /%[sdj%]/g;\n\tfunction format(f) {\n\t  if (!isString(f)) {\n\t    var objects = [];\n\n\t    for (var i = 0; i < arguments.length; i++) {\n\t      objects.push(inspect(arguments[i]));\n\t    }\n\n\t    return objects.join(' ');\n\t  }\n\n\t  var i = 1;\n\t  var args = arguments;\n\t  var len = args.length;\n\t  var str = String(f).replace(formatRegExp, function (x) {\n\t    if (x === '%%') return '%';\n\t    if (i >= len) return x;\n\n\t    switch (x) {\n\t      case '%s':\n\t        return String(args[i++]);\n\n\t      case '%d':\n\t        return Number(args[i++]);\n\n\t      case '%j':\n\t        try {\n\t          return JSON.stringify(args[i++]);\n\t        } catch (_) {\n\t          return '[Circular]';\n\t        }\n\n\t      default:\n\t        return x;\n\t    }\n\t  });\n\n\t  for (var x = args[i]; i < len; x = args[++i]) {\n\t    if (isNull(x) || !isObject(x)) {\n\t      str += ' ' + x;\n\t    } else {\n\t      str += ' ' + inspect(x);\n\t    }\n\t  }\n\n\t  return str;\n\t}\n\t// Returns a modified function which warns once by default.\n\t// If --no-deprecation is set, then it is a no-op.\n\n\tfunction deprecate(fn, msg) {\n\t  // Allow for deprecating things in the process of starting up.\n\t  if (isUndefined(global.process)) {\n\t    return function () {\n\t      return deprecate(fn, msg).apply(this, arguments);\n\t    };\n\t  }\n\n\t  var warned = false;\n\n\t  function deprecated() {\n\t    if (!warned) {\n\t      {\n\t        console.error(msg);\n\t      }\n\n\t      warned = true;\n\t    }\n\n\t    return fn.apply(this, arguments);\n\t  }\n\n\t  return deprecated;\n\t}\n\tvar debugs = {};\n\tvar debugEnviron;\n\tfunction debuglog(set) {\n\t  if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';\n\t  set = set.toUpperCase();\n\n\t  if (!debugs[set]) {\n\t    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n\t      var pid = 0;\n\n\t      debugs[set] = function () {\n\t        var msg = format.apply(null, arguments);\n\t        console.error('%s %d: %s', set, pid, msg);\n\t      };\n\t    } else {\n\t      debugs[set] = function () {};\n\t    }\n\t  }\n\n\t  return debugs[set];\n\t}\n\t/**\n\t * Echos the value of a value. Trys to print the value out\n\t * in the best way possible given the different types.\n\t *\n\t * @param {Object} obj The object to print out.\n\t * @param {Object} opts Optional options object that alters the output.\n\t */\n\n\t/* legacy: obj, showHidden, depth, colors*/\n\n\tfunction inspect(obj, opts) {\n\t  // default options\n\t  var ctx = {\n\t    seen: [],\n\t    stylize: stylizeNoColor\n\t  }; // legacy...\n\n\t  if (arguments.length >= 3) ctx.depth = arguments[2];\n\t  if (arguments.length >= 4) ctx.colors = arguments[3];\n\n\t  if (isBoolean(opts)) {\n\t    // legacy...\n\t    ctx.showHidden = opts;\n\t  } else if (opts) {\n\t    // got an \"options\" object\n\t    _extend(ctx, opts);\n\t  } // set default options\n\n\n\t  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n\t  if (isUndefined(ctx.depth)) ctx.depth = 2;\n\t  if (isUndefined(ctx.colors)) ctx.colors = false;\n\t  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n\t  if (ctx.colors) ctx.stylize = stylizeWithColor;\n\t  return formatValue(ctx, obj, ctx.depth);\n\t} // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\n\n\tinspect.colors = {\n\t  'bold': [1, 22],\n\t  'italic': [3, 23],\n\t  'underline': [4, 24],\n\t  'inverse': [7, 27],\n\t  'white': [37, 39],\n\t  'grey': [90, 39],\n\t  'black': [30, 39],\n\t  'blue': [34, 39],\n\t  'cyan': [36, 39],\n\t  'green': [32, 39],\n\t  'magenta': [35, 39],\n\t  'red': [31, 39],\n\t  'yellow': [33, 39]\n\t}; // Don't use 'blue' not visible on cmd.exe\n\n\tinspect.styles = {\n\t  'special': 'cyan',\n\t  'number': 'yellow',\n\t  'boolean': 'yellow',\n\t  'undefined': 'grey',\n\t  'null': 'bold',\n\t  'string': 'green',\n\t  'date': 'magenta',\n\t  // \"name\": intentionally not styling\n\t  'regexp': 'red'\n\t};\n\n\tfunction stylizeWithColor(str, styleType) {\n\t  var style = inspect.styles[styleType];\n\n\t  if (style) {\n\t    return \"\\x1B[\" + inspect.colors[style][0] + 'm' + str + \"\\x1B[\" + inspect.colors[style][1] + 'm';\n\t  } else {\n\t    return str;\n\t  }\n\t}\n\n\tfunction stylizeNoColor(str, styleType) {\n\t  return str;\n\t}\n\n\tfunction arrayToHash(array) {\n\t  var hash = {};\n\t  array.forEach(function (val, idx) {\n\t    hash[val] = true;\n\t  });\n\t  return hash;\n\t}\n\n\tfunction formatValue(ctx, value, recurseTimes) {\n\t  // Provide a hook for user-specified inspect functions.\n\t  // Check that value is an object with an inspect function on it\n\t  if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special\n\t  value.inspect !== inspect && // Also filter out any prototype objects using the circular check.\n\t  !(value.constructor && value.constructor.prototype === value)) {\n\t    var ret = value.inspect(recurseTimes, ctx);\n\n\t    if (!isString(ret)) {\n\t      ret = formatValue(ctx, ret, recurseTimes);\n\t    }\n\n\t    return ret;\n\t  } // Primitive types cannot have properties\n\n\n\t  var primitive = formatPrimitive(ctx, value);\n\n\t  if (primitive) {\n\t    return primitive;\n\t  } // Look up the keys of the object.\n\n\n\t  var keys = Object.keys(value);\n\t  var visibleKeys = arrayToHash(keys);\n\n\t  if (ctx.showHidden) {\n\t    keys = Object.getOwnPropertyNames(value);\n\t  } // IE doesn't make error fields non-enumerable\n\t  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n\n\n\t  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n\t    return formatError(value);\n\t  } // Some type of object without properties can be shortcutted.\n\n\n\t  if (keys.length === 0) {\n\t    if (isFunction(value)) {\n\t      var name = value.name ? ': ' + value.name : '';\n\t      return ctx.stylize('[Function' + name + ']', 'special');\n\t    }\n\n\t    if (isRegExp(value)) {\n\t      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n\t    }\n\n\t    if (isDate(value)) {\n\t      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n\t    }\n\n\t    if (isError(value)) {\n\t      return formatError(value);\n\t    }\n\t  }\n\n\t  var base = '',\n\t      array = false,\n\t      braces = ['{', '}']; // Make Array say that they are Array\n\n\t  if (isArray(value)) {\n\t    array = true;\n\t    braces = ['[', ']'];\n\t  } // Make functions say that they are functions\n\n\n\t  if (isFunction(value)) {\n\t    var n = value.name ? ': ' + value.name : '';\n\t    base = ' [Function' + n + ']';\n\t  } // Make RegExps say that they are RegExps\n\n\n\t  if (isRegExp(value)) {\n\t    base = ' ' + RegExp.prototype.toString.call(value);\n\t  } // Make dates with properties first say the date\n\n\n\t  if (isDate(value)) {\n\t    base = ' ' + Date.prototype.toUTCString.call(value);\n\t  } // Make error with message first say the error\n\n\n\t  if (isError(value)) {\n\t    base = ' ' + formatError(value);\n\t  }\n\n\t  if (keys.length === 0 && (!array || value.length == 0)) {\n\t    return braces[0] + base + braces[1];\n\t  }\n\n\t  if (recurseTimes < 0) {\n\t    if (isRegExp(value)) {\n\t      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n\t    } else {\n\t      return ctx.stylize('[Object]', 'special');\n\t    }\n\t  }\n\n\t  ctx.seen.push(value);\n\t  var output;\n\n\t  if (array) {\n\t    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n\t  } else {\n\t    output = keys.map(function (key) {\n\t      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n\t    });\n\t  }\n\n\t  ctx.seen.pop();\n\t  return reduceToSingleString(output, base, braces);\n\t}\n\n\tfunction formatPrimitive(ctx, value) {\n\t  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');\n\n\t  if (isString(value)) {\n\t    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '').replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"') + '\\'';\n\t    return ctx.stylize(simple, 'string');\n\t  }\n\n\t  if (isNumber(value)) return ctx.stylize('' + value, 'number');\n\t  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean'); // For some reason typeof null is \"object\", so special case here.\n\n\t  if (isNull(value)) return ctx.stylize('null', 'null');\n\t}\n\n\tfunction formatError(value) {\n\t  return '[' + Error.prototype.toString.call(value) + ']';\n\t}\n\n\tfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n\t  var output = [];\n\n\t  for (var i = 0, l = value.length; i < l; ++i) {\n\t    if (hasOwnProperty(value, String(i))) {\n\t      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));\n\t    } else {\n\t      output.push('');\n\t    }\n\t  }\n\n\t  keys.forEach(function (key) {\n\t    if (!key.match(/^\\d+$/)) {\n\t      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));\n\t    }\n\t  });\n\t  return output;\n\t}\n\n\tfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n\t  var name, str, desc;\n\t  desc = Object.getOwnPropertyDescriptor(value, key) || {\n\t    value: value[key]\n\t  };\n\n\t  if (desc.get) {\n\t    if (desc.set) {\n\t      str = ctx.stylize('[Getter/Setter]', 'special');\n\t    } else {\n\t      str = ctx.stylize('[Getter]', 'special');\n\t    }\n\t  } else {\n\t    if (desc.set) {\n\t      str = ctx.stylize('[Setter]', 'special');\n\t    }\n\t  }\n\n\t  if (!hasOwnProperty(visibleKeys, key)) {\n\t    name = '[' + key + ']';\n\t  }\n\n\t  if (!str) {\n\t    if (ctx.seen.indexOf(desc.value) < 0) {\n\t      if (isNull(recurseTimes)) {\n\t        str = formatValue(ctx, desc.value, null);\n\t      } else {\n\t        str = formatValue(ctx, desc.value, recurseTimes - 1);\n\t      }\n\n\t      if (str.indexOf('\\n') > -1) {\n\t        if (array) {\n\t          str = str.split('\\n').map(function (line) {\n\t            return '  ' + line;\n\t          }).join('\\n').substr(2);\n\t        } else {\n\t          str = '\\n' + str.split('\\n').map(function (line) {\n\t            return '   ' + line;\n\t          }).join('\\n');\n\t        }\n\t      }\n\t    } else {\n\t      str = ctx.stylize('[Circular]', 'special');\n\t    }\n\t  }\n\n\t  if (isUndefined(name)) {\n\t    if (array && key.match(/^\\d+$/)) {\n\t      return str;\n\t    }\n\n\t    name = JSON.stringify('' + key);\n\n\t    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n\t      name = name.substr(1, name.length - 2);\n\t      name = ctx.stylize(name, 'name');\n\t    } else {\n\t      name = name.replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"').replace(/(^\"|\"$)/g, \"'\");\n\t      name = ctx.stylize(name, 'string');\n\t    }\n\t  }\n\n\t  return name + ': ' + str;\n\t}\n\n\tfunction reduceToSingleString(output, base, braces) {\n\t  var length = output.reduce(function (prev, cur) {\n\t    if (cur.indexOf('\\n') >= 0) ;\n\t    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n\t  }, 0);\n\n\t  if (length > 60) {\n\t    return braces[0] + (base === '' ? '' : base + '\\n ') + ' ' + output.join(',\\n  ') + ' ' + braces[1];\n\t  }\n\n\t  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n\t} // NOTE: These type checking functions intentionally don't use `instanceof`\n\t// because it is fragile and can be easily faked with `Object.create()`.\n\n\n\tfunction isArray(ar) {\n\t  return Array.isArray(ar);\n\t}\n\tfunction isBoolean(arg) {\n\t  return typeof arg === 'boolean';\n\t}\n\tfunction isNull(arg) {\n\t  return arg === null;\n\t}\n\tfunction isNullOrUndefined(arg) {\n\t  return arg == null;\n\t}\n\tfunction isNumber(arg) {\n\t  return typeof arg === 'number';\n\t}\n\tfunction isString(arg) {\n\t  return typeof arg === 'string';\n\t}\n\tfunction isSymbol(arg) {\n\t  return _typeof$1(arg) === 'symbol';\n\t}\n\tfunction isUndefined(arg) {\n\t  return arg === void 0;\n\t}\n\tfunction isRegExp(re) {\n\t  return isObject(re) && objectToString(re) === '[object RegExp]';\n\t}\n\tfunction isObject(arg) {\n\t  return _typeof$1(arg) === 'object' && arg !== null;\n\t}\n\tfunction isDate(d) {\n\t  return isObject(d) && objectToString(d) === '[object Date]';\n\t}\n\tfunction isError(e) {\n\t  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);\n\t}\n\tfunction isFunction(arg) {\n\t  return typeof arg === 'function';\n\t}\n\tfunction isPrimitive(arg) {\n\t  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || _typeof$1(arg) === 'symbol' || // ES6 symbol\n\t  typeof arg === 'undefined';\n\t}\n\tfunction isBuffer(maybeBuf) {\n\t  return Buffer.isBuffer(maybeBuf);\n\t}\n\n\tfunction objectToString(o) {\n\t  return Object.prototype.toString.call(o);\n\t}\n\n\tfunction pad(n) {\n\t  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n\t}\n\n\tvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; // 26 Feb 16:19:34\n\n\tfunction timestamp$1() {\n\t  var d = new Date();\n\t  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');\n\t  return [d.getDate(), months[d.getMonth()], time].join(' ');\n\t} // log is just a thin wrapper to console.log that prepends a timestamp\n\n\n\tfunction log() {\n\t  console.log('%s - %s', timestamp$1(), format.apply(null, arguments));\n\t}\n\tfunction _extend(origin, add) {\n\t  // Don't do anything if add isn't an object\n\t  if (!add || !isObject(add)) return origin;\n\t  var keys = Object.keys(add);\n\t  var i = keys.length;\n\n\t  while (i--) {\n\t    origin[keys[i]] = add[keys[i]];\n\t  }\n\n\t  return origin;\n\t}\n\n\tfunction hasOwnProperty(obj, prop) {\n\t  return Object.prototype.hasOwnProperty.call(obj, prop);\n\t}\n\n\tvar util = {\n\t  inherits: inherits$1,\n\t  _extend: _extend,\n\t  log: log,\n\t  isBuffer: isBuffer,\n\t  isPrimitive: isPrimitive,\n\t  isFunction: isFunction,\n\t  isError: isError,\n\t  isDate: isDate,\n\t  isObject: isObject,\n\t  isRegExp: isRegExp,\n\t  isUndefined: isUndefined,\n\t  isSymbol: isSymbol,\n\t  isString: isString,\n\t  isNumber: isNumber,\n\t  isNullOrUndefined: isNullOrUndefined,\n\t  isNull: isNull,\n\t  isBoolean: isBoolean,\n\t  isArray: isArray,\n\t  inspect: inspect,\n\t  deprecate: deprecate,\n\t  format: format,\n\t  debuglog: debuglog\n\t};\n\n\tvar util$1 = /*#__PURE__*/Object.freeze({\n\t\tformat: format,\n\t\tdeprecate: deprecate,\n\t\tdebuglog: debuglog,\n\t\tinspect: inspect,\n\t\tisArray: isArray,\n\t\tisBoolean: isBoolean,\n\t\tisNull: isNull,\n\t\tisNullOrUndefined: isNullOrUndefined,\n\t\tisNumber: isNumber,\n\t\tisString: isString,\n\t\tisSymbol: isSymbol,\n\t\tisUndefined: isUndefined,\n\t\tisRegExp: isRegExp,\n\t\tisObject: isObject,\n\t\tisDate: isDate,\n\t\tisError: isError,\n\t\tisFunction: isFunction,\n\t\tisPrimitive: isPrimitive,\n\t\tisBuffer: isBuffer,\n\t\tlog: log,\n\t\tinherits: inherits$1,\n\t\t_extend: _extend,\n\t\tdefault: util\n\t});\n\n\tvar util$2 = getCjsExportFromNamespace(util$1);\n\n\tfunction _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$2(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }\n\n\tvar Buffer$1 = buffer.Buffer;\n\tvar randomBytes$1 = utils.randomBytes;\n\tvar deprecate$1 = util$2.deprecate; // constants\n\n\tvar PROCESS_UNIQUE = randomBytes$1(5); // Regular expression that checks for hex value\n\n\tvar checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');\n\tvar hasBufferType = false; // Check if buffer exists\n\n\ttry {\n\t  if (Buffer$1 && Buffer$1.from) hasBufferType = true;\n\t} catch (err) {\n\t  hasBufferType = false;\n\t} // Precomputed hex table enables speedy hex string conversion\n\n\n\tvar hexTable = [];\n\n\tfor (var _i = 0; _i < 256; _i++) {\n\t  hexTable[_i] = (_i <= 15 ? '0' : '') + _i.toString(16);\n\t} // Lookup tables\n\n\n\tvar decodeLookup = [];\n\tvar i = 0;\n\n\twhile (i < 10) {\n\t  decodeLookup[0x30 + i] = i++;\n\t}\n\n\twhile (i < 16) {\n\t  decodeLookup[0x41 - 10 + i] = decodeLookup[0x61 - 10 + i] = i++;\n\t}\n\n\tvar _Buffer = Buffer$1;\n\n\tfunction convertToHex(bytes) {\n\t  return bytes.toString('hex');\n\t}\n\n\tfunction makeObjectIdError(invalidString, index) {\n\t  var invalidCharacter = invalidString[index];\n\t  return new TypeError(\"ObjectId string \\\"\".concat(invalidString, \"\\\" contains invalid character \\\"\").concat(invalidCharacter, \"\\\" with character code (\").concat(invalidString.charCodeAt(index), \"). All character codes for a non-hex string must be less than 256.\"));\n\t}\n\t/**\n\t * A class representation of the BSON ObjectId type.\n\t */\n\n\n\tvar ObjectId =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create an ObjectId type\n\t   *\n\t   * @param {(string|Buffer|number)} id Can be a 24 byte hex string, 12 byte binary Buffer, or a Number.\n\t   * @property {number} generationTime The generation time of this ObjectId instance\n\t   * @return {ObjectId} instance of ObjectId.\n\t   */\n\t  function ObjectId(id) {\n\t    _classCallCheck$2(this, ObjectId);\n\n\t    // Duck-typing to support ObjectId from different npm packages\n\t    if (id instanceof ObjectId) return id; // The most common usecase (blank id, new objectId instance)\n\n\t    if (id == null || typeof id === 'number') {\n\t      // Generate a new id\n\t      this.id = ObjectId.generate(id); // If we are caching the hex string\n\n\t      if (ObjectId.cacheHexString) this.__id = this.toString('hex'); // Return the object\n\n\t      return;\n\t    } // Check if the passed in id is valid\n\n\n\t    var valid = ObjectId.isValid(id); // Throw an error if it's not a valid setup\n\n\t    if (!valid && id != null) {\n\t      throw new TypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');\n\t    } else if (valid && typeof id === 'string' && id.length === 24 && hasBufferType) {\n\t      return new ObjectId(Buffer$1.from(id, 'hex'));\n\t    } else if (valid && typeof id === 'string' && id.length === 24) {\n\t      return ObjectId.createFromHexString(id);\n\t    } else if (id != null && id.length === 12) {\n\t      // assume 12 byte string\n\t      this.id = id;\n\t    } else if (id != null && id.toHexString) {\n\t      // Duck-typing to support ObjectId from different npm packages\n\t      return ObjectId.createFromHexString(id.toHexString());\n\t    } else {\n\t      throw new TypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');\n\t    }\n\n\t    if (ObjectId.cacheHexString) this.__id = this.toString('hex');\n\t  }\n\t  /**\n\t   * Return the ObjectId id as a 24 byte hex string representation\n\t   *\n\t   * @method\n\t   * @return {string} return the 24 byte hex string representation.\n\t   */\n\n\n\t  _createClass$2(ObjectId, [{\n\t    key: \"toHexString\",\n\t    value: function toHexString() {\n\t      if (ObjectId.cacheHexString && this.__id) return this.__id;\n\t      var hexString = '';\n\n\t      if (!this.id || !this.id.length) {\n\t        throw new TypeError('invalid ObjectId, ObjectId.id must be either a string or a Buffer, but is [' + JSON.stringify(this.id) + ']');\n\t      }\n\n\t      if (this.id instanceof _Buffer) {\n\t        hexString = convertToHex(this.id);\n\t        if (ObjectId.cacheHexString) this.__id = hexString;\n\t        return hexString;\n\t      }\n\n\t      for (var _i2 = 0; _i2 < this.id.length; _i2++) {\n\t        var hexChar = hexTable[this.id.charCodeAt(_i2)];\n\n\t        if (typeof hexChar !== 'string') {\n\t          throw makeObjectIdError(this.id, _i2);\n\t        }\n\n\t        hexString += hexChar;\n\t      }\n\n\t      if (ObjectId.cacheHexString) this.__id = hexString;\n\t      return hexString;\n\t    }\n\t    /**\n\t     * Update the ObjectId index used in generating new ObjectId's on the driver\n\t     *\n\t     * @method\n\t     * @return {number} returns next index value.\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toString\",\n\n\t    /**\n\t     * Converts the id into a 24 byte hex string for printing\n\t     *\n\t     * @param {String} format The Buffer toString format parameter.\n\t     * @return {String} return the 24 byte hex string representation.\n\t     * @ignore\n\t     */\n\t    value: function toString(format) {\n\t      // Is the id a buffer then use the buffer toString method to return the format\n\t      if (this.id && this.id.copy) {\n\t        return this.id.toString(typeof format === 'string' ? format : 'hex');\n\t      }\n\n\t      return this.toHexString();\n\t    }\n\t    /**\n\t     * Converts to its JSON representation.\n\t     *\n\t     * @return {String} return the 24 byte hex string representation.\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.toHexString();\n\t    }\n\t    /**\n\t     * Compares the equality of this ObjectId with `otherID`.\n\t     *\n\t     * @method\n\t     * @param {object} otherId ObjectId instance to compare against.\n\t     * @return {boolean} the result of comparing two ObjectId's\n\t     */\n\n\t  }, {\n\t    key: \"equals\",\n\t    value: function equals(otherId) {\n\t      if (otherId instanceof ObjectId) {\n\t        return this.toString() === otherId.toString();\n\t      }\n\n\t      if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12 && this.id instanceof _Buffer) {\n\t        return otherId === this.id.toString('binary');\n\t      }\n\n\t      if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 24) {\n\t        return otherId.toLowerCase() === this.toHexString();\n\t      }\n\n\t      if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12) {\n\t        return otherId === this.id;\n\t      }\n\n\t      if (otherId != null && (otherId instanceof ObjectId || otherId.toHexString)) {\n\t        return otherId.toHexString() === this.toHexString();\n\t      }\n\n\t      return false;\n\t    }\n\t    /**\n\t     * Returns the generation date (accurate up to the second) that this ID was generated.\n\t     *\n\t     * @method\n\t     * @return {Date} the generation date\n\t     */\n\n\t  }, {\n\t    key: \"getTimestamp\",\n\t    value: function getTimestamp() {\n\t      var timestamp = new Date();\n\t      var time = this.id.readUInt32BE(0);\n\t      timestamp.setTime(Math.floor(time) * 1000);\n\t      return timestamp;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\n\t    /**\n\t     * @ignore\n\t     */\n\t    value: function toExtendedJSON() {\n\t      if (this.toHexString) return {\n\t        $oid: this.toHexString()\n\t      };\n\t      return {\n\t        $oid: this.toString('hex')\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"getInc\",\n\t    value: function getInc() {\n\t      return ObjectId.index = (ObjectId.index + 1) % 0xffffff;\n\t    }\n\t    /**\n\t     * Generate a 12 byte id buffer used in ObjectId's\n\t     *\n\t     * @method\n\t     * @param {number} [time] optional parameter allowing to pass in a second based timestamp.\n\t     * @return {Buffer} return the 12 byte id buffer string.\n\t     */\n\n\t  }, {\n\t    key: \"generate\",\n\t    value: function generate(time) {\n\t      if ('number' !== typeof time) {\n\t        time = ~~(Date.now() / 1000);\n\t      }\n\n\t      var inc = ObjectId.getInc();\n\t      var buffer$$1 = Buffer$1.alloc(12); // 4-byte timestamp\n\n\t      buffer$$1[3] = time & 0xff;\n\t      buffer$$1[2] = time >> 8 & 0xff;\n\t      buffer$$1[1] = time >> 16 & 0xff;\n\t      buffer$$1[0] = time >> 24 & 0xff; // 5-byte process unique\n\n\t      buffer$$1[4] = PROCESS_UNIQUE[0];\n\t      buffer$$1[5] = PROCESS_UNIQUE[1];\n\t      buffer$$1[6] = PROCESS_UNIQUE[2];\n\t      buffer$$1[7] = PROCESS_UNIQUE[3];\n\t      buffer$$1[8] = PROCESS_UNIQUE[4]; // 3-byte counter\n\n\t      buffer$$1[11] = inc & 0xff;\n\t      buffer$$1[10] = inc >> 8 & 0xff;\n\t      buffer$$1[9] = inc >> 16 & 0xff;\n\t      return buffer$$1;\n\t    }\n\t  }, {\n\t    key: \"createPk\",\n\t    value: function createPk() {\n\t      return new ObjectId();\n\t    }\n\t    /**\n\t     * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.\n\t     *\n\t     * @method\n\t     * @param {number} time an integer number representing a number of seconds.\n\t     * @return {ObjectId} return the created ObjectId\n\t     */\n\n\t  }, {\n\t    key: \"createFromTime\",\n\t    value: function createFromTime(time) {\n\t      var buffer$$1 = Buffer$1.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // Encode time into first 4 bytes\n\n\t      buffer$$1[3] = time & 0xff;\n\t      buffer$$1[2] = time >> 8 & 0xff;\n\t      buffer$$1[1] = time >> 16 & 0xff;\n\t      buffer$$1[0] = time >> 24 & 0xff; // Return the new objectId\n\n\t      return new ObjectId(buffer$$1);\n\t    }\n\t    /**\n\t     * Creates an ObjectId from a hex string representation of an ObjectId.\n\t     *\n\t     * @method\n\t     * @param {string} hexString create a ObjectId from a passed in 24 byte hexstring.\n\t     * @return {ObjectId} return the created ObjectId\n\t     */\n\n\t  }, {\n\t    key: \"createFromHexString\",\n\t    value: function createFromHexString(string) {\n\t      // Throw an error if it's not a valid setup\n\t      if (typeof string === 'undefined' || string != null && string.length !== 24) {\n\t        throw new TypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');\n\t      } // Use Buffer.from method if available\n\n\n\t      if (hasBufferType) return new ObjectId(Buffer$1.from(string, 'hex')); // Calculate lengths\n\n\t      var array = new _Buffer(12);\n\t      var n = 0;\n\t      var i = 0;\n\n\t      while (i < 24) {\n\t        array[n++] = decodeLookup[string.charCodeAt(i++)] << 4 | decodeLookup[string.charCodeAt(i++)];\n\t      }\n\n\t      return new ObjectId(array);\n\t    }\n\t    /**\n\t     * Checks if a value is a valid bson ObjectId\n\t     *\n\t     * @method\n\t     * @return {boolean} return true if the value is a valid bson ObjectId, return false otherwise.\n\t     */\n\n\t  }, {\n\t    key: \"isValid\",\n\t    value: function isValid(id) {\n\t      if (id == null) return false;\n\n\t      if (typeof id === 'number') {\n\t        return true;\n\t      }\n\n\t      if (typeof id === 'string') {\n\t        return id.length === 12 || id.length === 24 && checkForHexRegExp.test(id);\n\t      }\n\n\t      if (id instanceof ObjectId) {\n\t        return true;\n\t      }\n\n\t      if (id instanceof _Buffer && id.length === 12) {\n\t        return true;\n\t      } // Duck-Typing detection of ObjectId like objects\n\n\n\t      if (id.toHexString) {\n\t        return id.id.length === 12 || id.id.length === 24 && checkForHexRegExp.test(id.id);\n\t      }\n\n\t      return false;\n\t    }\n\t  }, {\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new ObjectId(doc.$oid);\n\t    }\n\t  }]);\n\n\t  return ObjectId;\n\t}(); // Deprecated methods\n\n\n\tObjectId.get_inc = deprecate$1(function () {\n\t  return ObjectId.getInc();\n\t}, 'Please use the static `ObjectId.getInc()` instead');\n\tObjectId.prototype.get_inc = deprecate$1(function () {\n\t  return ObjectId.getInc();\n\t}, 'Please use the static `ObjectId.getInc()` instead');\n\tObjectId.prototype.getInc = deprecate$1(function () {\n\t  return ObjectId.getInc();\n\t}, 'Please use the static `ObjectId.getInc()` instead');\n\tObjectId.prototype.generate = deprecate$1(function (time) {\n\t  return ObjectId.generate(time);\n\t}, 'Please use the static `ObjectId.generate(time)` instead');\n\t/**\n\t * @ignore\n\t */\n\n\tObject.defineProperty(ObjectId.prototype, 'generationTime', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return this.id[3] | this.id[2] << 8 | this.id[1] << 16 | this.id[0] << 24;\n\t  },\n\t  set: function set(value) {\n\t    // Encode time into first 4 bytes\n\t    this.id[3] = value & 0xff;\n\t    this.id[2] = value >> 8 & 0xff;\n\t    this.id[1] = value >> 16 & 0xff;\n\t    this.id[0] = value >> 24 & 0xff;\n\t  }\n\t});\n\t/**\n\t * Converts to a string representation of this Id.\n\t *\n\t * @return {String} return the 24 byte hex string representation.\n\t * @ignore\n\t */\n\n\tObjectId.prototype[util$2.inspect.custom || 'inspect'] = ObjectId.prototype.toString;\n\t/**\n\t * @ignore\n\t */\n\n\tObjectId.index = ~~(Math.random() * 0xffffff); // In 4.0.0 and 4.0.1, this property name was changed to ObjectId to match the class name.\n\t// This caused interoperability problems with previous versions of the library, so in\n\t// later builds we changed it back to ObjectID (capital D) to match legacy implementations.\n\n\tObject.defineProperty(ObjectId.prototype, '_bsontype', {\n\t  value: 'ObjectID'\n\t});\n\tvar objectid = ObjectId;\n\n\tfunction _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$3(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$3(Constructor.prototype, protoProps); if (staticProps) _defineProperties$3(Constructor, staticProps); return Constructor; }\n\n\tfunction alphabetize(str) {\n\t  return str.split('').sort().join('');\n\t}\n\t/**\n\t * A class representation of the BSON RegExp type.\n\t */\n\n\n\tvar BSONRegExp =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a RegExp type\n\t   *\n\t   * @param {string} pattern The regular expression pattern to match\n\t   * @param {string} options The regular expression options\n\t   */\n\t  function BSONRegExp(pattern, options) {\n\t    _classCallCheck$3(this, BSONRegExp);\n\n\t    // Execute\n\t    this.pattern = pattern || '';\n\t    this.options = options ? alphabetize(options) : ''; // Validate options\n\n\t    for (var i = 0; i < this.options.length; i++) {\n\t      if (!(this.options[i] === 'i' || this.options[i] === 'm' || this.options[i] === 'x' || this.options[i] === 'l' || this.options[i] === 's' || this.options[i] === 'u')) {\n\t        throw new Error(\"The regular expression option [\".concat(this.options[i], \"] is not supported\"));\n\t      }\n\t    }\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$3(BSONRegExp, [{\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $regularExpression: {\n\t          pattern: this.pattern,\n\t          options: this.options\n\t        }\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new BSONRegExp(doc.$regularExpression.pattern, doc.$regularExpression.options.split('').sort().join(''));\n\t    }\n\t  }]);\n\n\t  return BSONRegExp;\n\t}();\n\n\tObject.defineProperty(BSONRegExp.prototype, '_bsontype', {\n\t  value: 'BSONRegExp'\n\t});\n\tvar regexp = BSONRegExp;\n\n\t/**\n\t * A class representation of the BSON Symbol type.\n\t */\n\n\tfunction _classCallCheck$4(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$4(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$4(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$4(Constructor.prototype, protoProps); if (staticProps) _defineProperties$4(Constructor, staticProps); return Constructor; }\n\n\tvar BSONSymbol =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Symbol type\n\t   *\n\t   * @param {string} value the string representing the symbol.\n\t   */\n\t  function BSONSymbol(value) {\n\t    _classCallCheck$4(this, BSONSymbol);\n\n\t    this.value = value;\n\t  }\n\t  /**\n\t   * Access the wrapped string value.\n\t   *\n\t   * @method\n\t   * @return {String} returns the wrapped string.\n\t   */\n\n\n\t  _createClass$4(BSONSymbol, [{\n\t    key: \"valueOf\",\n\t    value: function valueOf() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toString\",\n\t    value: function toString() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"inspect\",\n\t    value: function inspect() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $symbol: this.value\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new BSONSymbol(doc.$symbol);\n\t    }\n\t  }]);\n\n\t  return BSONSymbol;\n\t}();\n\n\tObject.defineProperty(BSONSymbol.prototype, '_bsontype', {\n\t  value: 'Symbol'\n\t});\n\tvar symbol = BSONSymbol;\n\n\t/**\n\t * A class representation of a BSON Int32 type.\n\t */\n\n\tfunction _classCallCheck$5(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$5(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$5(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$5(Constructor.prototype, protoProps); if (staticProps) _defineProperties$5(Constructor, staticProps); return Constructor; }\n\n\tvar Int32 =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create an Int32 type\n\t   *\n\t   * @param {number} value the number we want to represent as an int32.\n\t   * @return {Int32}\n\t   */\n\t  function Int32(value) {\n\t    _classCallCheck$5(this, Int32);\n\n\t    this.value = value;\n\t  }\n\t  /**\n\t   * Access the number value.\n\t   *\n\t   * @method\n\t   * @return {number} returns the wrapped int32 number.\n\t   */\n\n\n\t  _createClass$5(Int32, [{\n\t    key: \"valueOf\",\n\t    value: function valueOf() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.value;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON(options) {\n\t      if (options && options.relaxed) return this.value;\n\t      return {\n\t        $numberInt: this.value.toString()\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc, options) {\n\t      return options && options.relaxed ? parseInt(doc.$numberInt, 10) : new Int32(doc.$numberInt);\n\t    }\n\t  }]);\n\n\t  return Int32;\n\t}();\n\n\tObject.defineProperty(Int32.prototype, '_bsontype', {\n\t  value: 'Int32'\n\t});\n\tvar int_32 = Int32;\n\n\t/**\n\t * A class representation of the BSON Code type.\n\t */\n\n\tfunction _classCallCheck$6(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$6(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$6(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$6(Constructor.prototype, protoProps); if (staticProps) _defineProperties$6(Constructor, staticProps); return Constructor; }\n\n\tvar Code =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Code type\n\t   *\n\t   * @param {(string|function)} code a string or function.\n\t   * @param {Object} [scope] an optional scope for the function.\n\t   * @return {Code}\n\t   */\n\t  function Code(code, scope) {\n\t    _classCallCheck$6(this, Code);\n\n\t    this.code = code;\n\t    this.scope = scope;\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$6(Code, [{\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return {\n\t        scope: this.scope,\n\t        code: this.code\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      if (this.scope) {\n\t        return {\n\t          $code: this.code,\n\t          $scope: this.scope\n\t        };\n\t      }\n\n\t      return {\n\t        $code: this.code\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      return new Code(doc.$code, doc.$scope);\n\t    }\n\t  }]);\n\n\t  return Code;\n\t}();\n\n\tObject.defineProperty(Code.prototype, '_bsontype', {\n\t  value: 'Code'\n\t});\n\tvar code = Code;\n\n\tvar Buffer$2 = buffer.Buffer;\n\tvar PARSE_STRING_REGEXP = /^(\\+|-)?(\\d+|(\\d*\\.\\d*))?(E|e)?([-+])?(\\d+)?$/;\n\tvar PARSE_INF_REGEXP = /^(\\+|-)?(Infinity|inf)$/i;\n\tvar PARSE_NAN_REGEXP = /^(\\+|-)?NaN$/i;\n\tvar EXPONENT_MAX = 6111;\n\tvar EXPONENT_MIN = -6176;\n\tvar EXPONENT_BIAS = 6176;\n\tvar MAX_DIGITS = 34; // Nan value bits as 32 bit values (due to lack of longs)\n\n\tvar NAN_BUFFER = [0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].reverse(); // Infinity value bits 32 bit values (due to lack of longs)\n\n\tvar INF_NEGATIVE_BUFFER = [0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].reverse();\n\tvar INF_POSITIVE_BUFFER = [0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].reverse();\n\tvar EXPONENT_REGEX = /^([-+])?(\\d+)?$/; // Detect if the value is a digit\n\n\tfunction isDigit(value) {\n\t  return !isNaN(parseInt(value, 10));\n\t} // Divide two uint128 values\n\n\n\tfunction divideu128(value) {\n\t  var DIVISOR = long_1.fromNumber(1000 * 1000 * 1000);\n\n\t  var _rem = long_1.fromNumber(0);\n\n\t  if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) {\n\t    return {\n\t      quotient: value,\n\t      rem: _rem\n\t    };\n\t  }\n\n\t  for (var i = 0; i <= 3; i++) {\n\t    // Adjust remainder to match value of next dividend\n\t    _rem = _rem.shiftLeft(32); // Add the divided to _rem\n\n\t    _rem = _rem.add(new long_1(value.parts[i], 0));\n\t    value.parts[i] = _rem.div(DIVISOR).low;\n\t    _rem = _rem.modulo(DIVISOR);\n\t  }\n\n\t  return {\n\t    quotient: value,\n\t    rem: _rem\n\t  };\n\t} // Multiply two Long values and return the 128 bit value\n\n\n\tfunction multiply64x2(left, right) {\n\t  if (!left && !right) {\n\t    return {\n\t      high: long_1.fromNumber(0),\n\t      low: long_1.fromNumber(0)\n\t    };\n\t  }\n\n\t  var leftHigh = left.shiftRightUnsigned(32);\n\t  var leftLow = new long_1(left.getLowBits(), 0);\n\t  var rightHigh = right.shiftRightUnsigned(32);\n\t  var rightLow = new long_1(right.getLowBits(), 0);\n\t  var productHigh = leftHigh.multiply(rightHigh);\n\t  var productMid = leftHigh.multiply(rightLow);\n\t  var productMid2 = leftLow.multiply(rightHigh);\n\t  var productLow = leftLow.multiply(rightLow);\n\t  productHigh = productHigh.add(productMid.shiftRightUnsigned(32));\n\t  productMid = new long_1(productMid.getLowBits(), 0).add(productMid2).add(productLow.shiftRightUnsigned(32));\n\t  productHigh = productHigh.add(productMid.shiftRightUnsigned(32));\n\t  productLow = productMid.shiftLeft(32).add(new long_1(productLow.getLowBits(), 0)); // Return the 128 bit result\n\n\t  return {\n\t    high: productHigh,\n\t    low: productLow\n\t  };\n\t}\n\n\tfunction lessThan(left, right) {\n\t  // Make values unsigned\n\t  var uhleft = left.high >>> 0;\n\t  var uhright = right.high >>> 0; // Compare high bits first\n\n\t  if (uhleft < uhright) {\n\t    return true;\n\t  } else if (uhleft === uhright) {\n\t    var ulleft = left.low >>> 0;\n\t    var ulright = right.low >>> 0;\n\t    if (ulleft < ulright) return true;\n\t  }\n\n\t  return false;\n\t}\n\n\tfunction invalidErr(string, message) {\n\t  throw new TypeError(\"\\\"\".concat(string, \"\\\" is not a valid Decimal128 string - \").concat(message));\n\t}\n\t/**\n\t * A class representation of the BSON Decimal128 type.\n\t *\n\t * @class\n\t * @param {Buffer} bytes a buffer containing the raw Decimal128 bytes.\n\t * @return {Double}\n\t */\n\n\n\tfunction Decimal128(bytes) {\n\t  this.bytes = bytes;\n\t}\n\t/**\n\t * Create a Decimal128 instance from a string representation\n\t *\n\t * @method\n\t * @param {string} string a numeric string representation.\n\t * @return {Decimal128} returns a Decimal128 instance.\n\t */\n\n\n\tDecimal128.fromString = function (string) {\n\t  // Parse state tracking\n\t  var isNegative = false;\n\t  var sawRadix = false;\n\t  var foundNonZero = false; // Total number of significant digits (no leading or trailing zero)\n\n\t  var significantDigits = 0; // Total number of significand digits read\n\n\t  var nDigitsRead = 0; // Total number of digits (no leading zeros)\n\n\t  var nDigits = 0; // The number of the digits after radix\n\n\t  var radixPosition = 0; // The index of the first non-zero in *str*\n\n\t  var firstNonZero = 0; // Digits Array\n\n\t  var digits = [0]; // The number of digits in digits\n\n\t  var nDigitsStored = 0; // Insertion pointer for digits\n\n\t  var digitsInsert = 0; // The index of the first non-zero digit\n\n\t  var firstDigit = 0; // The index of the last digit\n\n\t  var lastDigit = 0; // Exponent\n\n\t  var exponent = 0; // loop index over array\n\n\t  var i = 0; // The high 17 digits of the significand\n\n\t  var significandHigh = [0, 0]; // The low 17 digits of the significand\n\n\t  var significandLow = [0, 0]; // The biased exponent\n\n\t  var biasedExponent = 0; // Read index\n\n\t  var index = 0; // Naively prevent against REDOS attacks.\n\t  // TODO: implementing a custom parsing for this, or refactoring the regex would yield\n\t  //       further gains.\n\n\t  if (string.length >= 7000) {\n\t    throw new TypeError('' + string + ' not a valid Decimal128 string');\n\t  } // Results\n\n\n\t  var stringMatch = string.match(PARSE_STRING_REGEXP);\n\t  var infMatch = string.match(PARSE_INF_REGEXP);\n\t  var nanMatch = string.match(PARSE_NAN_REGEXP); // Validate the string\n\n\t  if (!stringMatch && !infMatch && !nanMatch || string.length === 0) {\n\t    throw new TypeError('' + string + ' not a valid Decimal128 string');\n\t  }\n\n\t  if (stringMatch) {\n\t    // full_match = stringMatch[0]\n\t    // sign = stringMatch[1]\n\t    var unsignedNumber = stringMatch[2]; // stringMatch[3] is undefined if a whole number (ex \"1\", 12\")\n\t    // but defined if a number w/ decimal in it (ex \"1.0, 12.2\")\n\n\t    var e = stringMatch[4];\n\t    var expSign = stringMatch[5];\n\t    var expNumber = stringMatch[6]; // they provided e, but didn't give an exponent number. for ex \"1e\"\n\n\t    if (e && expNumber === undefined) invalidErr(string, 'missing exponent power'); // they provided e, but didn't give a number before it. for ex \"e1\"\n\n\t    if (e && unsignedNumber === undefined) invalidErr(string, 'missing exponent base');\n\n\t    if (e === undefined && (expSign || expNumber)) {\n\t      invalidErr(string, 'missing e before exponent');\n\t    }\n\t  } // Get the negative or positive sign\n\n\n\t  if (string[index] === '+' || string[index] === '-') {\n\t    isNegative = string[index++] === '-';\n\t  } // Check if user passed Infinity or NaN\n\n\n\t  if (!isDigit(string[index]) && string[index] !== '.') {\n\t    if (string[index] === 'i' || string[index] === 'I') {\n\t      return new Decimal128(Buffer$2.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));\n\t    } else if (string[index] === 'N') {\n\t      return new Decimal128(Buffer$2.from(NAN_BUFFER));\n\t    }\n\t  } // Read all the digits\n\n\n\t  while (isDigit(string[index]) || string[index] === '.') {\n\t    if (string[index] === '.') {\n\t      if (sawRadix) invalidErr(string, 'contains multiple periods');\n\t      sawRadix = true;\n\t      index = index + 1;\n\t      continue;\n\t    }\n\n\t    if (nDigitsStored < 34) {\n\t      if (string[index] !== '0' || foundNonZero) {\n\t        if (!foundNonZero) {\n\t          firstNonZero = nDigitsRead;\n\t        }\n\n\t        foundNonZero = true; // Only store 34 digits\n\n\t        digits[digitsInsert++] = parseInt(string[index], 10);\n\t        nDigitsStored = nDigitsStored + 1;\n\t      }\n\t    }\n\n\t    if (foundNonZero) nDigits = nDigits + 1;\n\t    if (sawRadix) radixPosition = radixPosition + 1;\n\t    nDigitsRead = nDigitsRead + 1;\n\t    index = index + 1;\n\t  }\n\n\t  if (sawRadix && !nDigitsRead) throw new TypeError('' + string + ' not a valid Decimal128 string'); // Read exponent if exists\n\n\t  if (string[index] === 'e' || string[index] === 'E') {\n\t    // Read exponent digits\n\t    var match = string.substr(++index).match(EXPONENT_REGEX); // No digits read\n\n\t    if (!match || !match[2]) return new Decimal128(Buffer$2.from(NAN_BUFFER)); // Get exponent\n\n\t    exponent = parseInt(match[0], 10); // Adjust the index\n\n\t    index = index + match[0].length;\n\t  } // Return not a number\n\n\n\t  if (string[index]) return new Decimal128(Buffer$2.from(NAN_BUFFER)); // Done reading input\n\t  // Find first non-zero digit in digits\n\n\t  firstDigit = 0;\n\n\t  if (!nDigitsStored) {\n\t    firstDigit = 0;\n\t    lastDigit = 0;\n\t    digits[0] = 0;\n\t    nDigits = 1;\n\t    nDigitsStored = 1;\n\t    significantDigits = 0;\n\t  } else {\n\t    lastDigit = nDigitsStored - 1;\n\t    significantDigits = nDigits;\n\n\t    if (significantDigits !== 1) {\n\t      while (string[firstNonZero + significantDigits - 1] === '0') {\n\t        significantDigits = significantDigits - 1;\n\t      }\n\t    }\n\t  } // Normalization of exponent\n\t  // Correct exponent based on radix position, and shift significand as needed\n\t  // to represent user input\n\t  // Overflow prevention\n\n\n\t  if (exponent <= radixPosition && radixPosition - exponent > 1 << 14) {\n\t    exponent = EXPONENT_MIN;\n\t  } else {\n\t    exponent = exponent - radixPosition;\n\t  } // Attempt to normalize the exponent\n\n\n\t  while (exponent > EXPONENT_MAX) {\n\t    // Shift exponent to significand and decrease\n\t    lastDigit = lastDigit + 1;\n\n\t    if (lastDigit - firstDigit > MAX_DIGITS) {\n\t      // Check if we have a zero then just hard clamp, otherwise fail\n\t      var digitsString = digits.join('');\n\n\t      if (digitsString.match(/^0+$/)) {\n\t        exponent = EXPONENT_MAX;\n\t        break;\n\t      }\n\n\t      invalidErr(string, 'overflow');\n\t    }\n\n\t    exponent = exponent - 1;\n\t  }\n\n\t  while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {\n\t    // Shift last digit. can only do this if < significant digits than # stored.\n\t    if (lastDigit === 0 && significantDigits < nDigitsStored) {\n\t      exponent = EXPONENT_MIN;\n\t      significantDigits = 0;\n\t      break;\n\t    }\n\n\t    if (nDigitsStored < nDigits) {\n\t      // adjust to match digits not stored\n\t      nDigits = nDigits - 1;\n\t    } else {\n\t      // adjust to round\n\t      lastDigit = lastDigit - 1;\n\t    }\n\n\t    if (exponent < EXPONENT_MAX) {\n\t      exponent = exponent + 1;\n\t    } else {\n\t      // Check if we have a zero then just hard clamp, otherwise fail\n\t      var _digitsString = digits.join('');\n\n\t      if (_digitsString.match(/^0+$/)) {\n\t        exponent = EXPONENT_MAX;\n\t        break;\n\t      }\n\n\t      invalidErr(string, 'overflow');\n\t    }\n\t  } // Round\n\t  // We've normalized the exponent, but might still need to round.\n\n\n\t  if (lastDigit - firstDigit + 1 < significantDigits) {\n\t    var endOfString = nDigitsRead; // If we have seen a radix point, 'string' is 1 longer than we have\n\t    // documented with ndigits_read, so inc the position of the first nonzero\n\t    // digit and the position that digits are read to.\n\n\t    if (sawRadix) {\n\t      firstNonZero = firstNonZero + 1;\n\t      endOfString = endOfString + 1;\n\t    } // if negative, we need to increment again to account for - sign at start.\n\n\n\t    if (isNegative) {\n\t      firstNonZero = firstNonZero + 1;\n\t      endOfString = endOfString + 1;\n\t    }\n\n\t    var roundDigit = parseInt(string[firstNonZero + lastDigit + 1], 10);\n\t    var roundBit = 0;\n\n\t    if (roundDigit >= 5) {\n\t      roundBit = 1;\n\n\t      if (roundDigit === 5) {\n\t        roundBit = digits[lastDigit] % 2 === 1;\n\n\t        for (i = firstNonZero + lastDigit + 2; i < endOfString; i++) {\n\t          if (parseInt(string[i], 10)) {\n\t            roundBit = 1;\n\t            break;\n\t          }\n\t        }\n\t      }\n\t    }\n\n\t    if (roundBit) {\n\t      var dIdx = lastDigit;\n\n\t      for (; dIdx >= 0; dIdx--) {\n\t        if (++digits[dIdx] > 9) {\n\t          digits[dIdx] = 0; // overflowed most significant digit\n\n\t          if (dIdx === 0) {\n\t            if (exponent < EXPONENT_MAX) {\n\t              exponent = exponent + 1;\n\t              digits[dIdx] = 1;\n\t            } else {\n\t              return new Decimal128(Buffer$2.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));\n\t            }\n\t          }\n\t        }\n\t      }\n\t    }\n\t  } // Encode significand\n\t  // The high 17 digits of the significand\n\n\n\t  significandHigh = long_1.fromNumber(0); // The low 17 digits of the significand\n\n\t  significandLow = long_1.fromNumber(0); // read a zero\n\n\t  if (significantDigits === 0) {\n\t    significandHigh = long_1.fromNumber(0);\n\t    significandLow = long_1.fromNumber(0);\n\t  } else if (lastDigit - firstDigit < 17) {\n\t    var _dIdx = firstDigit;\n\t    significandLow = long_1.fromNumber(digits[_dIdx++]);\n\t    significandHigh = new long_1(0, 0);\n\n\t    for (; _dIdx <= lastDigit; _dIdx++) {\n\t      significandLow = significandLow.multiply(long_1.fromNumber(10));\n\t      significandLow = significandLow.add(long_1.fromNumber(digits[_dIdx]));\n\t    }\n\t  } else {\n\t    var _dIdx2 = firstDigit;\n\t    significandHigh = long_1.fromNumber(digits[_dIdx2++]);\n\n\t    for (; _dIdx2 <= lastDigit - 17; _dIdx2++) {\n\t      significandHigh = significandHigh.multiply(long_1.fromNumber(10));\n\t      significandHigh = significandHigh.add(long_1.fromNumber(digits[_dIdx2]));\n\t    }\n\n\t    significandLow = long_1.fromNumber(digits[_dIdx2++]);\n\n\t    for (; _dIdx2 <= lastDigit; _dIdx2++) {\n\t      significandLow = significandLow.multiply(long_1.fromNumber(10));\n\t      significandLow = significandLow.add(long_1.fromNumber(digits[_dIdx2]));\n\t    }\n\t  }\n\n\t  var significand = multiply64x2(significandHigh, long_1.fromString('100000000000000000'));\n\t  significand.low = significand.low.add(significandLow);\n\n\t  if (lessThan(significand.low, significandLow)) {\n\t    significand.high = significand.high.add(long_1.fromNumber(1));\n\t  } // Biased exponent\n\n\n\t  biasedExponent = exponent + EXPONENT_BIAS;\n\t  var dec = {\n\t    low: long_1.fromNumber(0),\n\t    high: long_1.fromNumber(0)\n\t  }; // Encode combination, exponent, and significand.\n\n\t  if (significand.high.shiftRightUnsigned(49).and(long_1.fromNumber(1)).equals(long_1.fromNumber(1))) {\n\t    // Encode '11' into bits 1 to 3\n\t    dec.high = dec.high.or(long_1.fromNumber(0x3).shiftLeft(61));\n\t    dec.high = dec.high.or(long_1.fromNumber(biasedExponent).and(long_1.fromNumber(0x3fff).shiftLeft(47)));\n\t    dec.high = dec.high.or(significand.high.and(long_1.fromNumber(0x7fffffffffff)));\n\t  } else {\n\t    dec.high = dec.high.or(long_1.fromNumber(biasedExponent & 0x3fff).shiftLeft(49));\n\t    dec.high = dec.high.or(significand.high.and(long_1.fromNumber(0x1ffffffffffff)));\n\t  }\n\n\t  dec.low = significand.low; // Encode sign\n\n\t  if (isNegative) {\n\t    dec.high = dec.high.or(long_1.fromString('9223372036854775808'));\n\t  } // Encode into a buffer\n\n\n\t  var buffer$$1 = Buffer$2.alloc(16);\n\t  index = 0; // Encode the low 64 bits of the decimal\n\t  // Encode low bits\n\n\t  buffer$$1[index++] = dec.low.low & 0xff;\n\t  buffer$$1[index++] = dec.low.low >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.low.low >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.low.low >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = dec.low.high & 0xff;\n\t  buffer$$1[index++] = dec.low.high >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.low.high >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.low.high >> 24 & 0xff; // Encode the high 64 bits of the decimal\n\t  // Encode low bits\n\n\t  buffer$$1[index++] = dec.high.low & 0xff;\n\t  buffer$$1[index++] = dec.high.low >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.high.low >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.high.low >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = dec.high.high & 0xff;\n\t  buffer$$1[index++] = dec.high.high >> 8 & 0xff;\n\t  buffer$$1[index++] = dec.high.high >> 16 & 0xff;\n\t  buffer$$1[index++] = dec.high.high >> 24 & 0xff; // Return the new Decimal128\n\n\t  return new Decimal128(buffer$$1);\n\t}; // Extract least significant 5 bits\n\n\n\tvar COMBINATION_MASK = 0x1f; // Extract least significant 14 bits\n\n\tvar EXPONENT_MASK = 0x3fff; // Value of combination field for Inf\n\n\tvar COMBINATION_INFINITY = 30; // Value of combination field for NaN\n\n\tvar COMBINATION_NAN = 31;\n\t/**\n\t * Create a string representation of the raw Decimal128 value\n\t *\n\t * @method\n\t * @return {string} returns a Decimal128 string representation.\n\t */\n\n\tDecimal128.prototype.toString = function () {\n\t  // Note: bits in this routine are referred to starting at 0,\n\t  // from the sign bit, towards the coefficient.\n\t  // bits 0 - 31\n\t  var high; // bits 32 - 63\n\n\t  var midh; // bits 64 - 95\n\n\t  var midl; // bits 96 - 127\n\n\t  var low; // bits 1 - 5\n\n\t  var combination; // decoded biased exponent (14 bits)\n\n\t  var biased_exponent; // the number of significand digits\n\n\t  var significand_digits = 0; // the base-10 digits in the significand\n\n\t  var significand = new Array(36);\n\n\t  for (var i = 0; i < significand.length; i++) {\n\t    significand[i] = 0;\n\t  } // read pointer into significand\n\n\n\t  var index = 0; // unbiased exponent\n\n\t  var exponent; // the exponent if scientific notation is used\n\n\t  var scientific_exponent; // true if the number is zero\n\n\t  var is_zero = false; // the most signifcant significand bits (50-46)\n\n\t  var significand_msb; // temporary storage for significand decoding\n\n\t  var significand128 = {\n\t    parts: new Array(4)\n\t  }; // indexing variables\n\n\t  var j, k; // Output string\n\n\t  var string = []; // Unpack index\n\n\t  index = 0; // Buffer reference\n\n\t  var buffer$$1 = this.bytes; // Unpack the low 64bits into a long\n\n\t  low = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t  midl = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Unpack the high 64bits into a long\n\n\t  midh = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t  high = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Unpack index\n\n\t  index = 0; // Create the state of the decimal\n\n\t  var dec = {\n\t    low: new long_1(low, midl),\n\t    high: new long_1(midh, high)\n\t  };\n\n\t  if (dec.high.lessThan(long_1.ZERO)) {\n\t    string.push('-');\n\t  } // Decode combination field and exponent\n\n\n\t  combination = high >> 26 & COMBINATION_MASK;\n\n\t  if (combination >> 3 === 3) {\n\t    // Check for 'special' values\n\t    if (combination === COMBINATION_INFINITY) {\n\t      return string.join('') + 'Infinity';\n\t    } else if (combination === COMBINATION_NAN) {\n\t      return 'NaN';\n\t    } else {\n\t      biased_exponent = high >> 15 & EXPONENT_MASK;\n\t      significand_msb = 0x08 + (high >> 14 & 0x01);\n\t    }\n\t  } else {\n\t    significand_msb = high >> 14 & 0x07;\n\t    biased_exponent = high >> 17 & EXPONENT_MASK;\n\t  }\n\n\t  exponent = biased_exponent - EXPONENT_BIAS; // Create string of significand digits\n\t  // Convert the 114-bit binary number represented by\n\t  // (significand_high, significand_low) to at most 34 decimal\n\t  // digits through modulo and division.\n\n\t  significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14);\n\t  significand128.parts[1] = midh;\n\t  significand128.parts[2] = midl;\n\t  significand128.parts[3] = low;\n\n\t  if (significand128.parts[0] === 0 && significand128.parts[1] === 0 && significand128.parts[2] === 0 && significand128.parts[3] === 0) {\n\t    is_zero = true;\n\t  } else {\n\t    for (k = 3; k >= 0; k--) {\n\t      var least_digits = 0; // Peform the divide\n\n\t      var result = divideu128(significand128);\n\t      significand128 = result.quotient;\n\t      least_digits = result.rem.low; // We now have the 9 least significant digits (in base 2).\n\t      // Convert and output to string.\n\n\t      if (!least_digits) continue;\n\n\t      for (j = 8; j >= 0; j--) {\n\t        // significand[k * 9 + j] = Math.round(least_digits % 10);\n\t        significand[k * 9 + j] = least_digits % 10; // least_digits = Math.round(least_digits / 10);\n\n\t        least_digits = Math.floor(least_digits / 10);\n\t      }\n\t    }\n\t  } // Output format options:\n\t  // Scientific - [-]d.dddE(+/-)dd or [-]dE(+/-)dd\n\t  // Regular    - ddd.ddd\n\n\n\t  if (is_zero) {\n\t    significand_digits = 1;\n\t    significand[index] = 0;\n\t  } else {\n\t    significand_digits = 36;\n\n\t    while (!significand[index]) {\n\t      significand_digits = significand_digits - 1;\n\t      index = index + 1;\n\t    }\n\t  }\n\n\t  scientific_exponent = significand_digits - 1 + exponent; // The scientific exponent checks are dictated by the string conversion\n\t  // specification and are somewhat arbitrary cutoffs.\n\t  //\n\t  // We must check exponent > 0, because if this is the case, the number\n\t  // has trailing zeros.  However, we *cannot* output these trailing zeros,\n\t  // because doing so would change the precision of the value, and would\n\t  // change stored data if the string converted number is round tripped.\n\n\t  if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) {\n\t    // Scientific format\n\t    // if there are too many significant digits, we should just be treating numbers\n\t    // as + or - 0 and using the non-scientific exponent (this is for the \"invalid\n\t    // representation should be treated as 0/-0\" spec cases in decimal128-1.json)\n\t    if (significand_digits > 34) {\n\t      string.push(0);\n\t      if (exponent > 0) string.push('E+' + exponent);else if (exponent < 0) string.push('E' + exponent);\n\t      return string.join('');\n\t    }\n\n\t    string.push(significand[index++]);\n\t    significand_digits = significand_digits - 1;\n\n\t    if (significand_digits) {\n\t      string.push('.');\n\t    }\n\n\t    for (var _i = 0; _i < significand_digits; _i++) {\n\t      string.push(significand[index++]);\n\t    } // Exponent\n\n\n\t    string.push('E');\n\n\t    if (scientific_exponent > 0) {\n\t      string.push('+' + scientific_exponent);\n\t    } else {\n\t      string.push(scientific_exponent);\n\t    }\n\t  } else {\n\t    // Regular format with no decimal place\n\t    if (exponent >= 0) {\n\t      for (var _i2 = 0; _i2 < significand_digits; _i2++) {\n\t        string.push(significand[index++]);\n\t      }\n\t    } else {\n\t      var radix_position = significand_digits + exponent; // non-zero digits before radix\n\n\t      if (radix_position > 0) {\n\t        for (var _i3 = 0; _i3 < radix_position; _i3++) {\n\t          string.push(significand[index++]);\n\t        }\n\t      } else {\n\t        string.push('0');\n\t      }\n\n\t      string.push('.'); // add leading zeros after radix\n\n\t      while (radix_position++ < 0) {\n\t        string.push('0');\n\t      }\n\n\t      for (var _i4 = 0; _i4 < significand_digits - Math.max(radix_position - 1, 0); _i4++) {\n\t        string.push(significand[index++]);\n\t      }\n\t    }\n\t  }\n\n\t  return string.join('');\n\t};\n\n\tDecimal128.prototype.toJSON = function () {\n\t  return {\n\t    $numberDecimal: this.toString()\n\t  };\n\t};\n\t/**\n\t * @ignore\n\t */\n\n\n\tDecimal128.prototype.toExtendedJSON = function () {\n\t  return {\n\t    $numberDecimal: this.toString()\n\t  };\n\t};\n\t/**\n\t * @ignore\n\t */\n\n\n\tDecimal128.fromExtendedJSON = function (doc) {\n\t  return Decimal128.fromString(doc.$numberDecimal);\n\t};\n\n\tObject.defineProperty(Decimal128.prototype, '_bsontype', {\n\t  value: 'Decimal128'\n\t});\n\tvar decimal128 = Decimal128;\n\n\t/**\n\t * A class representation of the BSON MinKey type.\n\t */\n\n\tfunction _classCallCheck$7(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$7(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$7(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$7(Constructor.prototype, protoProps); if (staticProps) _defineProperties$7(Constructor, staticProps); return Constructor; }\n\n\tvar MinKey =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a MinKey type\n\t   *\n\t   * @return {MinKey} A MinKey instance\n\t   */\n\t  function MinKey() {\n\t    _classCallCheck$7(this, MinKey);\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$7(MinKey, [{\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $minKey: 1\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON() {\n\t      return new MinKey();\n\t    }\n\t  }]);\n\n\t  return MinKey;\n\t}();\n\n\tObject.defineProperty(MinKey.prototype, '_bsontype', {\n\t  value: 'MinKey'\n\t});\n\tvar min_key = MinKey;\n\n\t/**\n\t * A class representation of the BSON MaxKey type.\n\t */\n\n\tfunction _classCallCheck$8(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$8(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$8(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$8(Constructor.prototype, protoProps); if (staticProps) _defineProperties$8(Constructor, staticProps); return Constructor; }\n\n\tvar MaxKey =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a MaxKey type\n\t   *\n\t   * @return {MaxKey} A MaxKey instance\n\t   */\n\t  function MaxKey() {\n\t    _classCallCheck$8(this, MaxKey);\n\t  }\n\t  /**\n\t   * @ignore\n\t   */\n\n\n\t  _createClass$8(MaxKey, [{\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      return {\n\t        $maxKey: 1\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON() {\n\t      return new MaxKey();\n\t    }\n\t  }]);\n\n\t  return MaxKey;\n\t}();\n\n\tObject.defineProperty(MaxKey.prototype, '_bsontype', {\n\t  value: 'MaxKey'\n\t});\n\tvar max_key = MaxKey;\n\n\t/**\n\t * A class representation of the BSON DBRef type.\n\t */\n\n\tfunction _classCallCheck$9(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$9(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$9(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$9(Constructor.prototype, protoProps); if (staticProps) _defineProperties$9(Constructor, staticProps); return Constructor; }\n\n\tvar DBRef =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a DBRef type\n\t   *\n\t   * @param {string} collection the collection name.\n\t   * @param {ObjectId} oid the reference ObjectId.\n\t   * @param {string} [db] optional db name, if omitted the reference is local to the current db.\n\t   * @return {DBRef}\n\t   */\n\t  function DBRef(collection, oid, db, fields) {\n\t    _classCallCheck$9(this, DBRef);\n\n\t    // check if namespace has been provided\n\t    var parts = collection.split('.');\n\n\t    if (parts.length === 2) {\n\t      db = parts.shift();\n\t      collection = parts.shift();\n\t    }\n\n\t    this.collection = collection;\n\t    this.oid = oid;\n\t    this.db = db;\n\t    this.fields = fields || {};\n\t  }\n\t  /**\n\t   * @ignore\n\t   * @api private\n\t   */\n\n\n\t  _createClass$9(DBRef, [{\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      var o = Object.assign({\n\t        $ref: this.collection,\n\t        $id: this.oid\n\t      }, this.fields);\n\t      if (this.db != null) o.$db = this.db;\n\t      return o;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      var o = {\n\t        $ref: this.collection,\n\t        $id: this.oid\n\t      };\n\t      if (this.db) o.$db = this.db;\n\t      o = Object.assign(o, this.fields);\n\t      return o;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      var copy = Object.assign({}, doc);\n\t      ['$ref', '$id', '$db'].forEach(function (k) {\n\t        return delete copy[k];\n\t      });\n\t      return new DBRef(doc.$ref, doc.$id, doc.$db, copy);\n\t    }\n\t  }]);\n\n\t  return DBRef;\n\t}();\n\n\tObject.defineProperty(DBRef.prototype, '_bsontype', {\n\t  value: 'DBRef'\n\t}); // the 1.x parser used a \"namespace\" property, while 4.x uses \"collection\". To ensure backwards\n\t// compatibility, let's expose \"namespace\"\n\n\tObject.defineProperty(DBRef.prototype, 'namespace', {\n\t  get: function get() {\n\t    return this.collection;\n\t  },\n\t  set: function set(val) {\n\t    this.collection = val;\n\t  },\n\t  configurable: false\n\t});\n\tvar db_ref = DBRef;\n\n\tfunction _classCallCheck$a(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\tfunction _defineProperties$a(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n\tfunction _createClass$a(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$a(Constructor.prototype, protoProps); if (staticProps) _defineProperties$a(Constructor, staticProps); return Constructor; }\n\n\tvar Buffer$3 = buffer.Buffer;\n\t/**\n\t * A class representation of the BSON Binary type.\n\t */\n\n\tvar Binary =\n\t/*#__PURE__*/\n\tfunction () {\n\t  /**\n\t   * Create a Binary type\n\t   *\n\t   * Sub types\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_DEFAULT**, default BSON type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_FUNCTION**, BSON function type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY**, BSON byte array type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_UUID**, BSON uuid type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_MD5**, BSON md5 type.\n\t   *  - **BSON.BSON_BINARY_SUBTYPE_USER_DEFINED**, BSON user defined type.\n\t   *\n\t   * @param {Buffer} buffer a buffer object containing the binary data.\n\t   * @param {Number} [subType] the option binary type.\n\t   * @return {Binary}\n\t   */\n\t  function Binary(buffer$$1, subType) {\n\t    _classCallCheck$a(this, Binary);\n\n\t    if (buffer$$1 != null && !(typeof buffer$$1 === 'string') && !Buffer$3.isBuffer(buffer$$1) && !(buffer$$1 instanceof Uint8Array) && !Array.isArray(buffer$$1)) {\n\t      throw new TypeError('only String, Buffer, Uint8Array or Array accepted');\n\t    }\n\n\t    this.sub_type = subType == null ? BSON_BINARY_SUBTYPE_DEFAULT : subType;\n\t    this.position = 0;\n\n\t    if (buffer$$1 != null && !(buffer$$1 instanceof Number)) {\n\t      // Only accept Buffer, Uint8Array or Arrays\n\t      if (typeof buffer$$1 === 'string') {\n\t        // Different ways of writing the length of the string for the different types\n\t        if (typeof Buffer$3 !== 'undefined') {\n\t          this.buffer = Buffer$3.from(buffer$$1);\n\t        } else if (typeof Uint8Array !== 'undefined' || Array.isArray(buffer$$1)) {\n\t          this.buffer = writeStringToArray(buffer$$1);\n\t        } else {\n\t          throw new TypeError('only String, Buffer, Uint8Array or Array accepted');\n\t        }\n\t      } else {\n\t        this.buffer = buffer$$1;\n\t      }\n\n\t      this.position = buffer$$1.length;\n\t    } else {\n\t      if (typeof Buffer$3 !== 'undefined') {\n\t        this.buffer = Buffer$3.alloc(Binary.BUFFER_SIZE);\n\t      } else if (typeof Uint8Array !== 'undefined') {\n\t        this.buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE));\n\t      } else {\n\t        this.buffer = new Array(Binary.BUFFER_SIZE);\n\t      }\n\t    }\n\t  }\n\t  /**\n\t   * Updates this binary with byte_value.\n\t   *\n\t   * @method\n\t   * @param {string} byte_value a single byte we wish to write.\n\t   */\n\n\n\t  _createClass$a(Binary, [{\n\t    key: \"put\",\n\t    value: function put(byte_value) {\n\t      // If it's a string and a has more than one character throw an error\n\t      if (byte_value['length'] != null && typeof byte_value !== 'number' && byte_value.length !== 1) throw new TypeError('only accepts single character String, Uint8Array or Array');\n\t      if (typeof byte_value !== 'number' && byte_value < 0 || byte_value > 255) throw new TypeError('only accepts number in a valid unsigned byte range 0-255'); // Decode the byte value once\n\n\t      var decoded_byte = null;\n\n\t      if (typeof byte_value === 'string') {\n\t        decoded_byte = byte_value.charCodeAt(0);\n\t      } else if (byte_value['length'] != null) {\n\t        decoded_byte = byte_value[0];\n\t      } else {\n\t        decoded_byte = byte_value;\n\t      }\n\n\t      if (this.buffer.length > this.position) {\n\t        this.buffer[this.position++] = decoded_byte;\n\t      } else {\n\t        if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer)) {\n\t          // Create additional overflow buffer\n\t          var buffer$$1 = Buffer$3.alloc(Binary.BUFFER_SIZE + this.buffer.length); // Combine the two buffers together\n\n\t          this.buffer.copy(buffer$$1, 0, 0, this.buffer.length);\n\t          this.buffer = buffer$$1;\n\t          this.buffer[this.position++] = decoded_byte;\n\t        } else {\n\t          var _buffer = null; // Create a new buffer (typed or normal array)\n\n\t          if (isUint8Array(this.buffer)) {\n\t            _buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE + this.buffer.length));\n\t          } else {\n\t            _buffer = new Array(Binary.BUFFER_SIZE + this.buffer.length);\n\t          } // We need to copy all the content to the new array\n\n\n\t          for (var i = 0; i < this.buffer.length; i++) {\n\t            _buffer[i] = this.buffer[i];\n\t          } // Reassign the buffer\n\n\n\t          this.buffer = _buffer; // Write the byte\n\n\t          this.buffer[this.position++] = decoded_byte;\n\t        }\n\t      }\n\t    }\n\t    /**\n\t     * Writes a buffer or string to the binary.\n\t     *\n\t     * @method\n\t     * @param {(Buffer|string)} string a string or buffer to be written to the Binary BSON object.\n\t     * @param {number} offset specify the binary of where to write the content.\n\t     * @return {null}\n\t     */\n\n\t  }, {\n\t    key: \"write\",\n\t    value: function write(string, offset) {\n\t      offset = typeof offset === 'number' ? offset : this.position; // If the buffer is to small let's extend the buffer\n\n\t      if (this.buffer.length < offset + string.length) {\n\t        var buffer$$1 = null; // If we are in node.js\n\n\t        if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer)) {\n\t          buffer$$1 = Buffer$3.alloc(this.buffer.length + string.length);\n\t          this.buffer.copy(buffer$$1, 0, 0, this.buffer.length);\n\t        } else if (isUint8Array(this.buffer)) {\n\t          // Create a new buffer\n\t          buffer$$1 = new Uint8Array(new ArrayBuffer(this.buffer.length + string.length)); // Copy the content\n\n\t          for (var i = 0; i < this.position; i++) {\n\t            buffer$$1[i] = this.buffer[i];\n\t          }\n\t        } // Assign the new buffer\n\n\n\t        this.buffer = buffer$$1;\n\t      }\n\n\t      if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(string) && Buffer$3.isBuffer(this.buffer)) {\n\t        string.copy(this.buffer, offset, 0, string.length);\n\t        this.position = offset + string.length > this.position ? offset + string.length : this.position; // offset = string.length\n\t      } else if (typeof Buffer$3 !== 'undefined' && typeof string === 'string' && Buffer$3.isBuffer(this.buffer)) {\n\t        this.buffer.write(string, offset, 'binary');\n\t        this.position = offset + string.length > this.position ? offset + string.length : this.position; // offset = string.length;\n\t      } else if (isUint8Array(string) || Array.isArray(string) && typeof string !== 'string') {\n\t        for (var _i = 0; _i < string.length; _i++) {\n\t          this.buffer[offset++] = string[_i];\n\t        }\n\n\t        this.position = offset > this.position ? offset : this.position;\n\t      } else if (typeof string === 'string') {\n\t        for (var _i2 = 0; _i2 < string.length; _i2++) {\n\t          this.buffer[offset++] = string.charCodeAt(_i2);\n\t        }\n\n\t        this.position = offset > this.position ? offset : this.position;\n\t      }\n\t    }\n\t    /**\n\t     * Reads **length** bytes starting at **position**.\n\t     *\n\t     * @method\n\t     * @param {number} position read from the given position in the Binary.\n\t     * @param {number} length the number of bytes to read.\n\t     * @return {Buffer}\n\t     */\n\n\t  }, {\n\t    key: \"read\",\n\t    value: function read(position, length) {\n\t      length = length && length > 0 ? length : this.position; // Let's return the data based on the type we have\n\n\t      if (this.buffer['slice']) {\n\t        return this.buffer.slice(position, position + length);\n\t      } // Create a buffer to keep the result\n\n\n\t      var buffer$$1 = typeof Uint8Array !== 'undefined' ? new Uint8Array(new ArrayBuffer(length)) : new Array(length);\n\n\t      for (var i = 0; i < length; i++) {\n\t        buffer$$1[i] = this.buffer[position++];\n\t      } // Return the buffer\n\n\n\t      return buffer$$1;\n\t    }\n\t    /**\n\t     * Returns the value of this binary as a string.\n\t     *\n\t     * @method\n\t     * @return {string}\n\t     */\n\n\t  }, {\n\t    key: \"value\",\n\t    value: function value(asRaw) {\n\t      asRaw = asRaw == null ? false : asRaw; // Optimize to serialize for the situation where the data == size of buffer\n\n\t      if (asRaw && typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer) && this.buffer.length === this.position) return this.buffer; // If it's a node.js buffer object\n\n\t      if (typeof Buffer$3 !== 'undefined' && Buffer$3.isBuffer(this.buffer)) {\n\t        return asRaw ? this.buffer.slice(0, this.position) : this.buffer.toString('binary', 0, this.position);\n\t      } else {\n\t        if (asRaw) {\n\t          // we support the slice command use it\n\t          if (this.buffer['slice'] != null) {\n\t            return this.buffer.slice(0, this.position);\n\t          } else {\n\t            // Create a new buffer to copy content to\n\t            var newBuffer = isUint8Array(this.buffer) ? new Uint8Array(new ArrayBuffer(this.position)) : new Array(this.position); // Copy content\n\n\t            for (var i = 0; i < this.position; i++) {\n\t              newBuffer[i] = this.buffer[i];\n\t            } // Return the buffer\n\n\n\t            return newBuffer;\n\t          }\n\t        } else {\n\t          return convertArraytoUtf8BinaryString(this.buffer, 0, this.position);\n\t        }\n\t      }\n\t    }\n\t    /**\n\t     * Length.\n\t     *\n\t     * @method\n\t     * @return {number} the length of the binary.\n\t     */\n\n\t  }, {\n\t    key: \"length\",\n\t    value: function length() {\n\t      return this.position;\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toJSON\",\n\t    value: function toJSON() {\n\t      return this.buffer != null ? this.buffer.toString('base64') : '';\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toString\",\n\t    value: function toString(format) {\n\t      return this.buffer != null ? this.buffer.slice(0, this.position).toString(format) : '';\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }, {\n\t    key: \"toExtendedJSON\",\n\t    value: function toExtendedJSON() {\n\t      var base64String = Buffer$3.isBuffer(this.buffer) ? this.buffer.toString('base64') : Buffer$3.from(this.buffer).toString('base64');\n\t      var subType = Number(this.sub_type).toString(16);\n\t      return {\n\t        $binary: {\n\t          base64: base64String,\n\t          subType: subType.length === 1 ? '0' + subType : subType\n\t        }\n\t      };\n\t    }\n\t    /**\n\t     * @ignore\n\t     */\n\n\t  }], [{\n\t    key: \"fromExtendedJSON\",\n\t    value: function fromExtendedJSON(doc) {\n\t      var type = doc.$binary.subType ? parseInt(doc.$binary.subType, 16) : 0;\n\t      var data = Buffer$3.from(doc.$binary.base64, 'base64');\n\t      return new Binary(data, type);\n\t    }\n\t  }]);\n\n\t  return Binary;\n\t}();\n\t/**\n\t * Binary default subtype\n\t * @ignore\n\t */\n\n\n\tvar BSON_BINARY_SUBTYPE_DEFAULT = 0;\n\n\tfunction isUint8Array(obj) {\n\t  return Object.prototype.toString.call(obj) === '[object Uint8Array]';\n\t}\n\t/**\n\t * @ignore\n\t */\n\n\n\tfunction writeStringToArray(data) {\n\t  // Create a buffer\n\t  var buffer$$1 = typeof Uint8Array !== 'undefined' ? new Uint8Array(new ArrayBuffer(data.length)) : new Array(data.length); // Write the content to the buffer\n\n\t  for (var i = 0; i < data.length; i++) {\n\t    buffer$$1[i] = data.charCodeAt(i);\n\t  } // Write the string to the buffer\n\n\n\t  return buffer$$1;\n\t}\n\t/**\n\t * Convert Array ot Uint8Array to Binary String\n\t *\n\t * @ignore\n\t */\n\n\n\tfunction convertArraytoUtf8BinaryString(byteArray, startIndex, endIndex) {\n\t  var result = '';\n\n\t  for (var i = startIndex; i < endIndex; i++) {\n\t    result = result + String.fromCharCode(byteArray[i]);\n\t  }\n\n\t  return result;\n\t}\n\n\tBinary.BUFFER_SIZE = 256;\n\t/**\n\t * Default BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_DEFAULT = 0;\n\t/**\n\t * Function BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_FUNCTION = 1;\n\t/**\n\t * Byte Array BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_BYTE_ARRAY = 2;\n\t/**\n\t * OLD UUID BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_UUID_OLD = 3;\n\t/**\n\t * UUID BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_UUID = 4;\n\t/**\n\t * MD5 BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_MD5 = 5;\n\t/**\n\t * User BSON type\n\t *\n\t * @classconstant SUBTYPE_DEFAULT\n\t **/\n\n\tBinary.SUBTYPE_USER_DEFINED = 128;\n\tObject.defineProperty(Binary.prototype, '_bsontype', {\n\t  value: 'Binary'\n\t});\n\tvar binary = Binary;\n\n\tvar constants = {\n\t  // BSON MAX VALUES\n\t  BSON_INT32_MAX: 0x7fffffff,\n\t  BSON_INT32_MIN: -0x80000000,\n\t  BSON_INT64_MAX: Math.pow(2, 63) - 1,\n\t  BSON_INT64_MIN: -Math.pow(2, 63),\n\t  // JS MAX PRECISE VALUES\n\t  JS_INT_MAX: 0x20000000000000,\n\t  // Any integer up to 2^53 can be precisely represented by a double.\n\t  JS_INT_MIN: -0x20000000000000,\n\t  // Any integer down to -2^53 can be precisely represented by a double.\n\n\t  /**\n\t   * Number BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_NUMBER\n\t   **/\n\t  BSON_DATA_NUMBER: 1,\n\n\t  /**\n\t   * String BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_STRING\n\t   **/\n\t  BSON_DATA_STRING: 2,\n\n\t  /**\n\t   * Object BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_OBJECT\n\t   **/\n\t  BSON_DATA_OBJECT: 3,\n\n\t  /**\n\t   * Array BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_ARRAY\n\t   **/\n\t  BSON_DATA_ARRAY: 4,\n\n\t  /**\n\t   * Binary BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_BINARY\n\t   **/\n\t  BSON_DATA_BINARY: 5,\n\n\t  /**\n\t   * Binary BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_UNDEFINED\n\t   **/\n\t  BSON_DATA_UNDEFINED: 6,\n\n\t  /**\n\t   * ObjectId BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_OID\n\t   **/\n\t  BSON_DATA_OID: 7,\n\n\t  /**\n\t   * Boolean BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_BOOLEAN\n\t   **/\n\t  BSON_DATA_BOOLEAN: 8,\n\n\t  /**\n\t   * Date BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_DATE\n\t   **/\n\t  BSON_DATA_DATE: 9,\n\n\t  /**\n\t   * null BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_NULL\n\t   **/\n\t  BSON_DATA_NULL: 10,\n\n\t  /**\n\t   * RegExp BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_REGEXP\n\t   **/\n\t  BSON_DATA_REGEXP: 11,\n\n\t  /**\n\t   * Code BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_DBPOINTER\n\t   **/\n\t  BSON_DATA_DBPOINTER: 12,\n\n\t  /**\n\t   * Code BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_CODE\n\t   **/\n\t  BSON_DATA_CODE: 13,\n\n\t  /**\n\t   * Symbol BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_SYMBOL\n\t   **/\n\t  BSON_DATA_SYMBOL: 14,\n\n\t  /**\n\t   * Code with Scope BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_CODE_W_SCOPE\n\t   **/\n\t  BSON_DATA_CODE_W_SCOPE: 15,\n\n\t  /**\n\t   * 32 bit Integer BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_INT\n\t   **/\n\t  BSON_DATA_INT: 16,\n\n\t  /**\n\t   * Timestamp BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_TIMESTAMP\n\t   **/\n\t  BSON_DATA_TIMESTAMP: 17,\n\n\t  /**\n\t   * Long BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_LONG\n\t   **/\n\t  BSON_DATA_LONG: 18,\n\n\t  /**\n\t   * Long BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_DECIMAL128\n\t   **/\n\t  BSON_DATA_DECIMAL128: 19,\n\n\t  /**\n\t   * MinKey BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_MIN_KEY\n\t   **/\n\t  BSON_DATA_MIN_KEY: 0xff,\n\n\t  /**\n\t   * MaxKey BSON Type\n\t   *\n\t   * @classconstant BSON_DATA_MAX_KEY\n\t   **/\n\t  BSON_DATA_MAX_KEY: 0x7f,\n\n\t  /**\n\t   * Binary Default Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_DEFAULT\n\t   **/\n\t  BSON_BINARY_SUBTYPE_DEFAULT: 0,\n\n\t  /**\n\t   * Binary Function Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_FUNCTION\n\t   **/\n\t  BSON_BINARY_SUBTYPE_FUNCTION: 1,\n\n\t  /**\n\t   * Binary Byte Array Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_BYTE_ARRAY\n\t   **/\n\t  BSON_BINARY_SUBTYPE_BYTE_ARRAY: 2,\n\n\t  /**\n\t   * Binary UUID Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_UUID\n\t   **/\n\t  BSON_BINARY_SUBTYPE_UUID: 3,\n\n\t  /**\n\t   * Binary MD5 Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_MD5\n\t   **/\n\t  BSON_BINARY_SUBTYPE_MD5: 4,\n\n\t  /**\n\t   * Binary User Defined Type\n\t   *\n\t   * @classconstant BSON_BINARY_SUBTYPE_USER_DEFINED\n\t   **/\n\t  BSON_BINARY_SUBTYPE_USER_DEFINED: 128\n\t};\n\n\tfunction _typeof$2(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$2(obj); }\n\t// const Map = require('./map');\n\n\t/**\n\t * @namespace EJSON\n\t */\n\t// all the types where we don't need to do any special processing and can just pass the EJSON\n\t//straight to type.fromExtendedJSON\n\n\n\tvar keysToCodecs = {\n\t  $oid: objectid,\n\t  $binary: binary,\n\t  $symbol: symbol,\n\t  $numberInt: int_32,\n\t  $numberDecimal: decimal128,\n\t  $numberDouble: double_1,\n\t  $numberLong: long_1,\n\t  $minKey: min_key,\n\t  $maxKey: max_key,\n\t  $regularExpression: regexp,\n\t  $timestamp: timestamp\n\t};\n\n\tfunction deserializeValue(self, key, value, options) {\n\t  if (typeof value === 'number') {\n\t    if (options.relaxed) {\n\t      return value;\n\t    } // if it's an integer, should interpret as smallest BSON integer\n\t    // that can represent it exactly. (if out of range, interpret as double.)\n\n\n\t    if (Math.floor(value) === value) {\n\t      if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) return new int_32(value);\n\t      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) return new long_1.fromNumber(value);\n\t    } // If the number is a non-integer or out of integer range, should interpret as BSON Double.\n\n\n\t    return new double_1(value);\n\t  } // from here on out we're looking for bson types, so bail if its not an object\n\n\n\t  if (value == null || _typeof$2(value) !== 'object') return value; // upgrade deprecated undefined to null\n\n\t  if (value.$undefined) return null;\n\t  var keys = Object.keys(value).filter(function (k) {\n\t    return k.startsWith('$') && value[k] != null;\n\t  });\n\n\t  for (var i = 0; i < keys.length; i++) {\n\t    var c = keysToCodecs[keys[i]];\n\t    if (c) return c.fromExtendedJSON(value, options);\n\t  }\n\n\t  if (value.$date != null) {\n\t    var d = value.$date;\n\t    var date = new Date();\n\t    if (typeof d === 'string') date.setTime(Date.parse(d));else if (long_1.isLong(d)) date.setTime(d.toNumber());else if (typeof d === 'number' && options.relaxed) date.setTime(d);\n\t    return date;\n\t  }\n\n\t  if (value.$code != null) {\n\t    var copy = Object.assign({}, value);\n\n\t    if (value.$scope) {\n\t      copy.$scope = deserializeValue(self, null, value.$scope);\n\t    }\n\n\t    return code.fromExtendedJSON(value);\n\t  }\n\n\t  if (value.$ref != null || value.$dbPointer != null) {\n\t    var v = value.$ref ? value : value.$dbPointer; // we run into this in a \"degenerate EJSON\" case (with $id and $ref order flipped)\n\t    // because of the order JSON.parse goes through the document\n\n\t    if (v instanceof db_ref) return v;\n\t    var dollarKeys = Object.keys(v).filter(function (k) {\n\t      return k.startsWith('$');\n\t    });\n\t    var valid = true;\n\t    dollarKeys.forEach(function (k) {\n\t      if (['$ref', '$id', '$db'].indexOf(k) === -1) valid = false;\n\t    }); // only make DBRef if $ keys are all valid\n\n\t    if (valid) return db_ref.fromExtendedJSON(v);\n\t  }\n\n\t  return value;\n\t}\n\t/**\n\t * Parse an Extended JSON string, constructing the JavaScript value or object described by that\n\t * string.\n\t *\n\t * @memberof EJSON\n\t * @param {string} text\n\t * @param {object} [options] Optional settings\n\t * @param {boolean} [options.relaxed=true] Attempt to return native JS types where possible, rather than BSON types (if true)\n\t * @return {object}\n\t *\n\t * @example\n\t * const { EJSON } = require('bson');\n\t * const text = '{ \"int32\": { \"$numberInt\": \"10\" } }';\n\t *\n\t * // prints { int32: { [String: '10'] _bsontype: 'Int32', value: '10' } }\n\t * console.log(EJSON.parse(text, { relaxed: false }));\n\t *\n\t * // prints { int32: 10 }\n\t * console.log(EJSON.parse(text));\n\t */\n\n\n\tfunction parse(text, options) {\n\t  var _this = this;\n\n\t  options = Object.assign({}, {\n\t    relaxed: true\n\t  }, options); // relaxed implies not strict\n\n\t  if (typeof options.relaxed === 'boolean') options.strict = !options.relaxed;\n\t  if (typeof options.strict === 'boolean') options.relaxed = !options.strict;\n\t  return JSON.parse(text, function (key, value) {\n\t    return deserializeValue(_this, key, value, options);\n\t  });\n\t} //\n\t// Serializer\n\t//\n\t// MAX INT32 boundaries\n\n\n\tvar BSON_INT32_MAX = 0x7fffffff,\n\t    BSON_INT32_MIN = -0x80000000,\n\t    BSON_INT64_MAX = 0x7fffffffffffffff,\n\t    BSON_INT64_MIN = -0x8000000000000000;\n\t/**\n\t * Converts a BSON document to an Extended JSON string, optionally replacing values if a replacer\n\t * function is specified or optionally including only the specified properties if a replacer array\n\t * is specified.\n\t *\n\t * @memberof EJSON\n\t * @param {object} value The value to convert to extended JSON\n\t * @param {function|array} [replacer] A function that alters the behavior of the stringification process, or an array of String and Number objects that serve as a whitelist for selecting/filtering the properties of the value object to be included in the JSON string. If this value is null or not provided, all properties of the object are included in the resulting JSON string\n\t * @param {string|number} [space] A String or Number object that's used to insert white space into the output JSON string for readability purposes.\n\t * @param {object} [options] Optional settings\n\t * @param {boolean} [options.relaxed=true] Enabled Extended JSON's `relaxed` mode\n\t * @returns {string}\n\t *\n\t * @example\n\t * const { EJSON } = require('bson');\n\t * const Int32 = require('mongodb').Int32;\n\t * const doc = { int32: new Int32(10) };\n\t *\n\t * // prints '{\"int32\":{\"$numberInt\":\"10\"}}'\n\t * console.log(EJSON.stringify(doc, { relaxed: false }));\n\t *\n\t * // prints '{\"int32\":10}'\n\t * console.log(EJSON.stringify(doc));\n\t */\n\n\tfunction stringify(value, replacer, space, options) {\n\t  if (space != null && _typeof$2(space) === 'object') {\n\t    options = space;\n\t    space = 0;\n\t  }\n\n\t  if (replacer != null && _typeof$2(replacer) === 'object' && !Array.isArray(replacer)) {\n\t    options = replacer;\n\t    replacer = null;\n\t    space = 0;\n\t  }\n\n\t  options = Object.assign({}, {\n\t    relaxed: true\n\t  }, options);\n\t  var doc = Array.isArray(value) ? serializeArray(value, options) : serializeDocument(value, options);\n\t  return JSON.stringify(doc, replacer, space);\n\t}\n\t/**\n\t * Serializes an object to an Extended JSON string, and reparse it as a JavaScript object.\n\t *\n\t * @memberof EJSON\n\t * @param {object} bson The object to serialize\n\t * @param {object} [options] Optional settings passed to the `stringify` function\n\t * @return {object}\n\t */\n\n\n\tfunction serialize(bson, options) {\n\t  options = options || {};\n\t  return JSON.parse(stringify(bson, options));\n\t}\n\t/**\n\t * Deserializes an Extended JSON object into a plain JavaScript object with native/BSON types\n\t *\n\t * @memberof EJSON\n\t * @param {object} ejson The Extended JSON object to deserialize\n\t * @param {object} [options] Optional settings passed to the parse method\n\t * @return {object}\n\t */\n\n\n\tfunction deserialize(ejson, options) {\n\t  options = options || {};\n\t  return parse(JSON.stringify(ejson), options);\n\t}\n\n\tfunction serializeArray(array, options) {\n\t  return array.map(function (v) {\n\t    return serializeValue(v, options);\n\t  });\n\t}\n\n\tfunction getISOString(date) {\n\t  var isoStr = date.toISOString(); // we should only show milliseconds in timestamp if they're non-zero\n\n\t  return date.getUTCMilliseconds() !== 0 ? isoStr : isoStr.slice(0, -5) + 'Z';\n\t}\n\n\tfunction serializeValue(value, options) {\n\t  if (Array.isArray(value)) return serializeArray(value, options);\n\t  if (value === undefined) return null;\n\n\t  if (value instanceof Date) {\n\t    var dateNum = value.getTime(),\n\t        // is it in year range 1970-9999?\n\t    inRange = dateNum > -1 && dateNum < 253402318800000;\n\t    return options.relaxed && inRange ? {\n\t      $date: getISOString(value)\n\t    } : {\n\t      $date: {\n\t        $numberLong: value.getTime().toString()\n\t      }\n\t    };\n\t  }\n\n\t  if (typeof value === 'number' && !options.relaxed) {\n\t    // it's an integer\n\t    if (Math.floor(value) === value) {\n\t      var int32Range = value >= BSON_INT32_MIN && value <= BSON_INT32_MAX,\n\t          int64Range = value >= BSON_INT64_MIN && value <= BSON_INT64_MAX; // interpret as being of the smallest BSON integer type that can represent the number exactly\n\n\t      if (int32Range) return {\n\t        $numberInt: value.toString()\n\t      };\n\t      if (int64Range) return {\n\t        $numberLong: value.toString()\n\t      };\n\t    }\n\n\t    return {\n\t      $numberDouble: value.toString()\n\t    };\n\t  }\n\n\t  if (value instanceof RegExp) {\n\t    var flags = value.flags;\n\n\t    if (flags === undefined) {\n\t      flags = value.toString().match(/[gimuy]*$/)[0];\n\t    }\n\n\t    var rx = new regexp(value.source, flags);\n\t    return rx.toExtendedJSON();\n\t  }\n\n\t  if (value != null && _typeof$2(value) === 'object') return serializeDocument(value, options);\n\t  return value;\n\t}\n\n\tvar BSON_TYPE_MAPPINGS = {\n\t  Binary: function Binary(o) {\n\t    return new binary(o.value(), o.subtype);\n\t  },\n\t  Code: function Code(o) {\n\t    return new code(o.code, o.scope);\n\t  },\n\t  DBRef: function DBRef(o) {\n\t    return new db_ref(o.collection || o.namespace, o.oid, o.db, o.fields);\n\t  },\n\t  // \"namespace\" for 1.x library backwards compat\n\t  Decimal128: function Decimal128(o) {\n\t    return new decimal128(o.bytes);\n\t  },\n\t  Double: function Double(o) {\n\t    return new double_1(o.value);\n\t  },\n\t  Int32: function Int32(o) {\n\t    return new int_32(o.value);\n\t  },\n\t  Long: function Long(o) {\n\t    return long_1.fromBits( // underscore variants for 1.x backwards compatibility\n\t    o.low != null ? o.low : o.low_, o.low != null ? o.high : o.high_, o.low != null ? o.unsigned : o.unsigned_);\n\t  },\n\t  MaxKey: function MaxKey() {\n\t    return new max_key();\n\t  },\n\t  MinKey: function MinKey() {\n\t    return new min_key();\n\t  },\n\t  ObjectID: function ObjectID(o) {\n\t    return new objectid(o);\n\t  },\n\t  ObjectId: function ObjectId(o) {\n\t    return new objectid(o);\n\t  },\n\t  // support 4.0.0/4.0.1 before _bsontype was reverted back to ObjectID\n\t  BSONRegExp: function BSONRegExp(o) {\n\t    return new regexp(o.pattern, o.options);\n\t  },\n\t  Symbol: function Symbol(o) {\n\t    return new symbol(o.value);\n\t  },\n\t  Timestamp: function Timestamp(o) {\n\t    return timestamp.fromBits(o.low, o.high);\n\t  }\n\t};\n\n\tfunction serializeDocument(doc, options) {\n\t  if (doc == null || _typeof$2(doc) !== 'object') throw new Error('not an object instance');\n\t  var bsontype = doc._bsontype;\n\n\t  if (typeof bsontype === 'undefined') {\n\t    // It's a regular object. Recursively serialize its property values.\n\t    var _doc = {};\n\n\t    for (var name in doc) {\n\t      _doc[name] = serializeValue(doc[name], options);\n\t    }\n\n\t    return _doc;\n\t  } else if (typeof bsontype === 'string') {\n\t    // the \"document\" is really just a BSON type object\n\t    var _doc2 = doc;\n\n\t    if (typeof _doc2.toExtendedJSON !== 'function') {\n\t      // There's no EJSON serialization function on the object. It's probably an\n\t      // object created by a previous version of this library (or another library)\n\t      // that's duck-typing objects to look like they were generated by this library).\n\t      // Copy the object into this library's version of that type.\n\t      var mapper = BSON_TYPE_MAPPINGS[bsontype];\n\n\t      if (!mapper) {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + bsontype);\n\t      }\n\n\t      _doc2 = mapper(_doc2);\n\t    } // Two BSON types may have nested objects that may need to be serialized too\n\n\n\t    if (bsontype === 'Code' && _doc2.scope) {\n\t      _doc2 = new code(_doc2.code, serializeValue(_doc2.scope, options));\n\t    } else if (bsontype === 'DBRef' && _doc2.oid) {\n\t      _doc2 = new db_ref(_doc2.collection, serializeValue(_doc2.oid, options), _doc2.db, _doc2.fields);\n\t    }\n\n\t    return _doc2.toExtendedJSON(options);\n\t  } else {\n\t    throw new Error('_bsontype must be a string, but was: ' + _typeof$2(bsontype));\n\t  }\n\t}\n\n\tvar extended_json = {\n\t  parse: parse,\n\t  deserialize: deserialize,\n\t  serialize: serialize,\n\t  stringify: stringify\n\t};\n\n\tvar FIRST_BIT = 0x80;\n\tvar FIRST_TWO_BITS = 0xc0;\n\tvar FIRST_THREE_BITS = 0xe0;\n\tvar FIRST_FOUR_BITS = 0xf0;\n\tvar FIRST_FIVE_BITS = 0xf8;\n\tvar TWO_BIT_CHAR = 0xc0;\n\tvar THREE_BIT_CHAR = 0xe0;\n\tvar FOUR_BIT_CHAR = 0xf0;\n\tvar CONTINUING_CHAR = 0x80;\n\t/**\n\t * Determines if the passed in bytes are valid utf8\n\t * @param {Buffer|Uint8Array} bytes An array of 8-bit bytes. Must be indexable and have length property\n\t * @param {Number} start The index to start validating\n\t * @param {Number} end The index to end validating\n\t * @returns {boolean} True if valid utf8\n\t */\n\n\tfunction validateUtf8(bytes, start, end) {\n\t  var continuation = 0;\n\n\t  for (var i = start; i < end; i += 1) {\n\t    var byte = bytes[i];\n\n\t    if (continuation) {\n\t      if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {\n\t        return false;\n\t      }\n\n\t      continuation -= 1;\n\t    } else if (byte & FIRST_BIT) {\n\t      if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {\n\t        continuation = 1;\n\t      } else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {\n\t        continuation = 2;\n\t      } else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {\n\t        continuation = 3;\n\t      } else {\n\t        return false;\n\t      }\n\t    }\n\t  }\n\n\t  return !continuation;\n\t}\n\n\tvar validateUtf8_1 = validateUtf8;\n\tvar validate_utf8 = {\n\t  validateUtf8: validateUtf8_1\n\t};\n\n\tvar Buffer$4 = buffer.Buffer;\n\tvar validateUtf8$1 = validate_utf8.validateUtf8; // Internal long versions\n\n\tvar JS_INT_MAX_LONG = long_1.fromNumber(constants.JS_INT_MAX);\n\tvar JS_INT_MIN_LONG = long_1.fromNumber(constants.JS_INT_MIN);\n\tvar functionCache = {};\n\n\tfunction deserialize$1(buffer$$1, options, isArray) {\n\t  options = options == null ? {} : options;\n\t  var index = options && options.index ? options.index : 0; // Read the document size\n\n\t  var size = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24;\n\n\t  if (size < 5) {\n\t    throw new Error(\"bson size must be >= 5, is \".concat(size));\n\t  }\n\n\t  if (options.allowObjectSmallerThanBufferSize && buffer$$1.length < size) {\n\t    throw new Error(\"buffer length \".concat(buffer$$1.length, \" must be >= bson size \").concat(size));\n\t  }\n\n\t  if (!options.allowObjectSmallerThanBufferSize && buffer$$1.length !== size) {\n\t    throw new Error(\"buffer length \".concat(buffer$$1.length, \" must === bson size \").concat(size));\n\t  }\n\n\t  if (size + index > buffer$$1.length) {\n\t    throw new Error(\"(bson size \".concat(size, \" + options.index \").concat(index, \" must be <= buffer length \").concat(Buffer$4.byteLength(buffer$$1), \")\"));\n\t  } // Illegal end value\n\n\n\t  if (buffer$$1[index + size - 1] !== 0) {\n\t    throw new Error(\"One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00\");\n\t  } // Start deserializtion\n\n\n\t  return deserializeObject(buffer$$1, index, options, isArray);\n\t}\n\n\tfunction deserializeObject(buffer$$1, index, options, isArray) {\n\t  var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];\n\t  var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];\n\t  var cacheFunctionsCrc32 = options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];\n\t  if (!cacheFunctionsCrc32) var crc32 = null;\n\t  var fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw']; // Return raw bson buffer instead of parsing it\n\n\t  var raw = options['raw'] == null ? false : options['raw']; // Return BSONRegExp objects instead of native regular expressions\n\n\t  var bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false; // Controls the promotion of values vs wrapper classes\n\n\t  var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];\n\t  var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];\n\t  var promoteValues = options['promoteValues'] == null ? true : options['promoteValues']; // Set the start index\n\n\t  var startIndex = index; // Validate that we have at least 4 bytes of buffer\n\n\t  if (buffer$$1.length < 5) throw new Error('corrupt bson message < 5 bytes long'); // Read the document size\n\n\t  var size = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Ensure buffer is valid size\n\n\t  if (size < 5 || size > buffer$$1.length) throw new Error('corrupt bson message'); // Create holding object\n\n\t  var object = isArray ? [] : {}; // Used for arrays to skip having to perform utf8 decoding\n\n\t  var arrayIndex = 0;\n\t  var done = false; // While we have more left data left keep parsing\n\n\t  while (!done) {\n\t    // Read the type\n\t    var elementType = buffer$$1[index++]; // If we get a zero it's the last byte, exit\n\n\t    if (elementType === 0) break; // Get the start search index\n\n\t    var i = index; // Locate the end of the c string\n\n\t    while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t      i++;\n\t    } // If are at the end of the buffer there is a problem with the document\n\n\n\t    if (i >= Buffer$4.byteLength(buffer$$1)) throw new Error('Bad BSON Document: illegal CString');\n\t    var name = isArray ? arrayIndex++ : buffer$$1.toString('utf8', index, i);\n\t    index = i + 1;\n\n\t    if (elementType === constants.BSON_DATA_STRING) {\n\t      var stringSize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      if (stringSize <= 0 || stringSize > buffer$$1.length - index || buffer$$1[index + stringSize - 1] !== 0) throw new Error('bad string length in bson');\n\n\t      if (!validateUtf8$1(buffer$$1, index, index + stringSize - 1)) {\n\t        throw new Error('Invalid UTF-8 string in BSON document');\n\t      }\n\n\t      var s = buffer$$1.toString('utf8', index, index + stringSize - 1);\n\t      object[name] = s;\n\t      index = index + stringSize;\n\t    } else if (elementType === constants.BSON_DATA_OID) {\n\t      var oid = Buffer$4.alloc(12);\n\t      buffer$$1.copy(oid, 0, index, index + 12);\n\t      object[name] = new objectid(oid);\n\t      index = index + 12;\n\t    } else if (elementType === constants.BSON_DATA_INT && promoteValues === false) {\n\t      object[name] = new int_32(buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24);\n\t    } else if (elementType === constants.BSON_DATA_INT) {\n\t      object[name] = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t    } else if (elementType === constants.BSON_DATA_NUMBER && promoteValues === false) {\n\t      object[name] = new double_1(buffer$$1.readDoubleLE(index));\n\t      index = index + 8;\n\t    } else if (elementType === constants.BSON_DATA_NUMBER) {\n\t      object[name] = buffer$$1.readDoubleLE(index);\n\t      index = index + 8;\n\t    } else if (elementType === constants.BSON_DATA_DATE) {\n\t      var lowBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      var highBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      object[name] = new Date(new long_1(lowBits, highBits).toNumber());\n\t    } else if (elementType === constants.BSON_DATA_BOOLEAN) {\n\t      if (buffer$$1[index] !== 0 && buffer$$1[index] !== 1) throw new Error('illegal boolean type value');\n\t      object[name] = buffer$$1[index++] === 1;\n\t    } else if (elementType === constants.BSON_DATA_OBJECT) {\n\t      var _index = index;\n\t      var objectSize = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24;\n\t      if (objectSize <= 0 || objectSize > buffer$$1.length - index) throw new Error('bad embedded document length in bson'); // We have a raw value\n\n\t      if (raw) {\n\t        object[name] = buffer$$1.slice(index, index + objectSize);\n\t      } else {\n\t        object[name] = deserializeObject(buffer$$1, _index, options, false);\n\t      }\n\n\t      index = index + objectSize;\n\t    } else if (elementType === constants.BSON_DATA_ARRAY) {\n\t      var _index2 = index;\n\n\t      var _objectSize = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24;\n\n\t      var arrayOptions = options; // Stop index\n\n\t      var stopIndex = index + _objectSize; // All elements of array to be returned as raw bson\n\n\t      if (fieldsAsRaw && fieldsAsRaw[name]) {\n\t        arrayOptions = {};\n\n\t        for (var n in options) {\n\t          arrayOptions[n] = options[n];\n\t        }\n\n\t        arrayOptions['raw'] = true;\n\t      }\n\n\t      object[name] = deserializeObject(buffer$$1, _index2, arrayOptions, true);\n\t      index = index + _objectSize;\n\t      if (buffer$$1[index - 1] !== 0) throw new Error('invalid array terminator byte');\n\t      if (index !== stopIndex) throw new Error('corrupted array bson');\n\t    } else if (elementType === constants.BSON_DATA_UNDEFINED) {\n\t      object[name] = undefined;\n\t    } else if (elementType === constants.BSON_DATA_NULL) {\n\t      object[name] = null;\n\t    } else if (elementType === constants.BSON_DATA_LONG) {\n\t      // Unpack the low and high bits\n\t      var _lowBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      var _highBits = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      var long$$1 = new long_1(_lowBits, _highBits); // Promote the long if possible\n\n\t      if (promoteLongs && promoteValues === true) {\n\t        object[name] = long$$1.lessThanOrEqual(JS_INT_MAX_LONG) && long$$1.greaterThanOrEqual(JS_INT_MIN_LONG) ? long$$1.toNumber() : long$$1;\n\t      } else {\n\t        object[name] = long$$1;\n\t      }\n\t    } else if (elementType === constants.BSON_DATA_DECIMAL128) {\n\t      // Buffer to contain the decimal bytes\n\t      var bytes = Buffer$4.alloc(16); // Copy the next 16 bytes into the bytes buffer\n\n\t      buffer$$1.copy(bytes, 0, index, index + 16); // Update index\n\n\t      index = index + 16; // Assign the new Decimal128 value\n\n\t      var decimal128$$1 = new decimal128(bytes); // If we have an alternative mapper use that\n\n\t      object[name] = decimal128$$1.toObject ? decimal128$$1.toObject() : decimal128$$1;\n\t    } else if (elementType === constants.BSON_DATA_BINARY) {\n\t      var binarySize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t      var totalBinarySize = binarySize;\n\t      var subType = buffer$$1[index++]; // Did we have a negative binary size, throw\n\n\t      if (binarySize < 0) throw new Error('Negative binary type element size found'); // Is the length longer than the document\n\n\t      if (binarySize > Buffer$4.byteLength(buffer$$1)) throw new Error('Binary type size larger than document size'); // Decode as raw Buffer object if options specifies it\n\n\t      if (buffer$$1['slice'] != null) {\n\t        // If we have subtype 2 skip the 4 bytes for the size\n\t        if (subType === binary.SUBTYPE_BYTE_ARRAY) {\n\t          binarySize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t          if (binarySize < 0) throw new Error('Negative binary type element size found for subtype 0x02');\n\t          if (binarySize > totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to long binary size');\n\t          if (binarySize < totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to short binary size');\n\t        }\n\n\t        if (promoteBuffers && promoteValues) {\n\t          object[name] = buffer$$1.slice(index, index + binarySize);\n\t        } else {\n\t          object[name] = new binary(buffer$$1.slice(index, index + binarySize), subType);\n\t        }\n\t      } else {\n\t        var _buffer = typeof Uint8Array !== 'undefined' ? new Uint8Array(new ArrayBuffer(binarySize)) : new Array(binarySize); // If we have subtype 2 skip the 4 bytes for the size\n\n\n\t        if (subType === binary.SUBTYPE_BYTE_ARRAY) {\n\t          binarySize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\t          if (binarySize < 0) throw new Error('Negative binary type element size found for subtype 0x02');\n\t          if (binarySize > totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to long binary size');\n\t          if (binarySize < totalBinarySize - 4) throw new Error('Binary type with subtype 0x02 contains to short binary size');\n\t        } // Copy the data\n\n\n\t        for (i = 0; i < binarySize; i++) {\n\t          _buffer[i] = buffer$$1[index + i];\n\t        }\n\n\t        if (promoteBuffers && promoteValues) {\n\t          object[name] = _buffer;\n\t        } else {\n\t          object[name] = new binary(_buffer, subType);\n\t        }\n\t      } // Update the index\n\n\n\t      index = index + binarySize;\n\t    } else if (elementType === constants.BSON_DATA_REGEXP && bsonRegExp === false) {\n\t      // Get the start search index\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var source = buffer$$1.toString('utf8', index, i); // Create the regexp\n\n\t      index = i + 1; // Get the start search index\n\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var regExpOptions = buffer$$1.toString('utf8', index, i);\n\t      index = i + 1; // For each option add the corresponding one for javascript\n\n\t      var optionsArray = new Array(regExpOptions.length); // Parse options\n\n\t      for (i = 0; i < regExpOptions.length; i++) {\n\t        switch (regExpOptions[i]) {\n\t          case 'm':\n\t            optionsArray[i] = 'm';\n\t            break;\n\n\t          case 's':\n\t            optionsArray[i] = 'g';\n\t            break;\n\n\t          case 'i':\n\t            optionsArray[i] = 'i';\n\t            break;\n\t        }\n\t      }\n\n\t      object[name] = new RegExp(source, optionsArray.join(''));\n\t    } else if (elementType === constants.BSON_DATA_REGEXP && bsonRegExp === true) {\n\t      // Get the start search index\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var _source = buffer$$1.toString('utf8', index, i);\n\n\t      index = i + 1; // Get the start search index\n\n\t      i = index; // Locate the end of the c string\n\n\t      while (buffer$$1[i] !== 0x00 && i < buffer$$1.length) {\n\t        i++;\n\t      } // If are at the end of the buffer there is a problem with the document\n\n\n\t      if (i >= buffer$$1.length) throw new Error('Bad BSON Document: illegal CString'); // Return the C string\n\n\t      var _regExpOptions = buffer$$1.toString('utf8', index, i);\n\n\t      index = i + 1; // Set the object\n\n\t      object[name] = new regexp(_source, _regExpOptions);\n\t    } else if (elementType === constants.BSON_DATA_SYMBOL) {\n\t      var _stringSize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      if (_stringSize <= 0 || _stringSize > buffer$$1.length - index || buffer$$1[index + _stringSize - 1] !== 0) throw new Error('bad string length in bson'); // symbol is deprecated - upgrade to string.\n\n\t      object[name] = buffer$$1.toString('utf8', index, index + _stringSize - 1);\n\t      index = index + _stringSize;\n\t    } else if (elementType === constants.BSON_DATA_TIMESTAMP) {\n\t      var _lowBits2 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      var _highBits2 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      object[name] = new timestamp(_lowBits2, _highBits2);\n\t    } else if (elementType === constants.BSON_DATA_MIN_KEY) {\n\t      object[name] = new min_key();\n\t    } else if (elementType === constants.BSON_DATA_MAX_KEY) {\n\t      object[name] = new max_key();\n\t    } else if (elementType === constants.BSON_DATA_CODE) {\n\t      var _stringSize2 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24;\n\n\t      if (_stringSize2 <= 0 || _stringSize2 > buffer$$1.length - index || buffer$$1[index + _stringSize2 - 1] !== 0) throw new Error('bad string length in bson');\n\t      var functionString = buffer$$1.toString('utf8', index, index + _stringSize2 - 1); // If we are evaluating the functions\n\n\t      if (evalFunctions) {\n\t        // If we have cache enabled let's look for the md5 of the function in the cache\n\t        if (cacheFunctions) {\n\t          var hash = cacheFunctionsCrc32 ? crc32(functionString) : functionString; // Got to do this to avoid V8 deoptimizing the call due to finding eval\n\n\t          object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);\n\t        } else {\n\t          object[name] = isolateEval(functionString);\n\t        }\n\t      } else {\n\t        object[name] = new code(functionString);\n\t      } // Update parse index position\n\n\n\t      index = index + _stringSize2;\n\t    } else if (elementType === constants.BSON_DATA_CODE_W_SCOPE) {\n\t      var totalSize = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Element cannot be shorter than totalSize + stringSize + documentSize + terminator\n\n\t      if (totalSize < 4 + 4 + 4 + 1) {\n\t        throw new Error('code_w_scope total size shorter minimum expected length');\n\t      } // Get the code string size\n\n\n\t      var _stringSize3 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Check if we have a valid string\n\n\n\t      if (_stringSize3 <= 0 || _stringSize3 > buffer$$1.length - index || buffer$$1[index + _stringSize3 - 1] !== 0) throw new Error('bad string length in bson'); // Javascript function\n\n\t      var _functionString = buffer$$1.toString('utf8', index, index + _stringSize3 - 1); // Update parse index position\n\n\n\t      index = index + _stringSize3; // Parse the element\n\n\t      var _index3 = index; // Decode the size of the object document\n\n\t      var _objectSize2 = buffer$$1[index] | buffer$$1[index + 1] << 8 | buffer$$1[index + 2] << 16 | buffer$$1[index + 3] << 24; // Decode the scope object\n\n\n\t      var scopeObject = deserializeObject(buffer$$1, _index3, options, false); // Adjust the index\n\n\t      index = index + _objectSize2; // Check if field length is to short\n\n\t      if (totalSize < 4 + 4 + _objectSize2 + _stringSize3) {\n\t        throw new Error('code_w_scope total size is to short, truncating scope');\n\t      } // Check if totalSize field is to long\n\n\n\t      if (totalSize > 4 + 4 + _objectSize2 + _stringSize3) {\n\t        throw new Error('code_w_scope total size is to long, clips outer document');\n\t      } // If we are evaluating the functions\n\n\n\t      if (evalFunctions) {\n\t        // If we have cache enabled let's look for the md5 of the function in the cache\n\t        if (cacheFunctions) {\n\t          var _hash = cacheFunctionsCrc32 ? crc32(_functionString) : _functionString; // Got to do this to avoid V8 deoptimizing the call due to finding eval\n\n\n\t          object[name] = isolateEvalWithHash(functionCache, _hash, _functionString, object);\n\t        } else {\n\t          object[name] = isolateEval(_functionString);\n\t        }\n\n\t        object[name].scope = scopeObject;\n\t      } else {\n\t        object[name] = new code(_functionString, scopeObject);\n\t      }\n\t    } else if (elementType === constants.BSON_DATA_DBPOINTER) {\n\t      // Get the code string size\n\t      var _stringSize4 = buffer$$1[index++] | buffer$$1[index++] << 8 | buffer$$1[index++] << 16 | buffer$$1[index++] << 24; // Check if we have a valid string\n\n\n\t      if (_stringSize4 <= 0 || _stringSize4 > buffer$$1.length - index || buffer$$1[index + _stringSize4 - 1] !== 0) throw new Error('bad string length in bson'); // Namespace\n\n\t      if (!validateUtf8$1(buffer$$1, index, index + _stringSize4 - 1)) {\n\t        throw new Error('Invalid UTF-8 string in BSON document');\n\t      }\n\n\t      var namespace = buffer$$1.toString('utf8', index, index + _stringSize4 - 1); // Update parse index position\n\n\t      index = index + _stringSize4; // Read the oid\n\n\t      var oidBuffer = Buffer$4.alloc(12);\n\t      buffer$$1.copy(oidBuffer, 0, index, index + 12);\n\n\t      var _oid = new objectid(oidBuffer); // Update the index\n\n\n\t      index = index + 12; // Upgrade to DBRef type\n\n\t      object[name] = new db_ref(namespace, _oid);\n\t    } else {\n\t      throw new Error('Detected unknown BSON type ' + elementType.toString(16) + ' for fieldname \"' + name + '\", are you using the latest BSON parser?');\n\t    }\n\t  } // Check if the deserialization was against a valid array/object\n\n\n\t  if (size !== index - startIndex) {\n\t    if (isArray) throw new Error('corrupt array bson');\n\t    throw new Error('corrupt object bson');\n\t  } // check if object's $ keys are those of a DBRef\n\n\n\t  var dollarKeys = Object.keys(object).filter(function (k) {\n\t    return k.startsWith('$');\n\t  });\n\t  var valid = true;\n\t  dollarKeys.forEach(function (k) {\n\t    if (['$ref', '$id', '$db'].indexOf(k) === -1) valid = false;\n\t  }); // if a $key not in \"$ref\", \"$id\", \"$db\", don't make a DBRef\n\n\t  if (!valid) return object;\n\n\t  if (object['$id'] != null && object['$ref'] != null) {\n\t    var copy = Object.assign({}, object);\n\t    delete copy.$ref;\n\t    delete copy.$id;\n\t    delete copy.$db;\n\t    return new db_ref(object.$ref, object.$id, object.$db || null, copy);\n\t  }\n\n\t  return object;\n\t}\n\t/**\n\t * Ensure eval is isolated.\n\t *\n\t * @ignore\n\t * @api private\n\t */\n\n\n\tfunction isolateEvalWithHash(functionCache, hash, functionString, object) {\n\t  // Contains the value we are going to set\n\t  var value = null; // Check for cache hit, eval if missing and return cached function\n\n\t  if (functionCache[hash] == null) {\n\t    eval('value = ' + functionString);\n\t    functionCache[hash] = value;\n\t  } // Set the object\n\n\n\t  return functionCache[hash].bind(object);\n\t}\n\t/**\n\t * Ensure eval is isolated.\n\t *\n\t * @ignore\n\t * @api private\n\t */\n\n\n\tfunction isolateEval(functionString) {\n\t  // Contains the value we are going to set\n\t  var value = null; // Eval the function\n\n\t  eval('value = ' + functionString);\n\t  return value;\n\t}\n\n\tvar deserializer = deserialize$1;\n\n\t// All rights reserved.\n\t//\n\t// Redistribution and use in source and binary forms, with or without\n\t// modification, are permitted provided that the following conditions are met:\n\t//\n\t//  * Redistributions of source code must retain the above copyright notice,\n\t//    this list of conditions and the following disclaimer.\n\t//\n\t//  * Redistributions in binary form must reproduce the above copyright notice,\n\t//    this list of conditions and the following disclaimer in the documentation\n\t//    and/or other materials provided with the distribution.\n\t//\n\t//  * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors\n\t//    may be used to endorse or promote products derived from this software\n\t//    without specific prior written permission.\n\t//\n\t// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n\t// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n\t// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n\t// ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n\t// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n\t// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n\t// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n\t// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n\t// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n\t// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n\t// POSSIBILITY OF SUCH DAMAGE.\n\t//\n\t//\n\t// Modifications to writeIEEE754 to support negative zeroes made by Brian White\n\n\tfunction readIEEE754(buffer$$1, offset, endian, mLen, nBytes) {\n\t  var e,\n\t      m,\n\t      bBE = endian === 'big',\n\t      eLen = nBytes * 8 - mLen - 1,\n\t      eMax = (1 << eLen) - 1,\n\t      eBias = eMax >> 1,\n\t      nBits = -7,\n\t      i = bBE ? 0 : nBytes - 1,\n\t      d = bBE ? 1 : -1,\n\t      s = buffer$$1[offset + i];\n\t  i += d;\n\t  e = s & (1 << -nBits) - 1;\n\t  s >>= -nBits;\n\t  nBits += eLen;\n\n\t  for (; nBits > 0; e = e * 256 + buffer$$1[offset + i], i += d, nBits -= 8) {\n\t  }\n\n\t  m = e & (1 << -nBits) - 1;\n\t  e >>= -nBits;\n\t  nBits += mLen;\n\n\t  for (; nBits > 0; m = m * 256 + buffer$$1[offset + i], i += d, nBits -= 8) {\n\t  }\n\n\t  if (e === 0) {\n\t    e = 1 - eBias;\n\t  } else if (e === eMax) {\n\t    return m ? NaN : (s ? -1 : 1) * Infinity;\n\t  } else {\n\t    m = m + Math.pow(2, mLen);\n\t    e = e - eBias;\n\t  }\n\n\t  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n\t}\n\n\tfunction writeIEEE754(buffer$$1, value, offset, endian, mLen, nBytes) {\n\t  var e,\n\t      m,\n\t      c,\n\t      bBE = endian === 'big',\n\t      eLen = nBytes * 8 - mLen - 1,\n\t      eMax = (1 << eLen) - 1,\n\t      eBias = eMax >> 1,\n\t      rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0,\n\t      i = bBE ? nBytes - 1 : 0,\n\t      d = bBE ? -1 : 1,\n\t      s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n\t  value = Math.abs(value);\n\n\t  if (isNaN(value) || value === Infinity) {\n\t    m = isNaN(value) ? 1 : 0;\n\t    e = eMax;\n\t  } else {\n\t    e = Math.floor(Math.log(value) / Math.LN2);\n\n\t    if (value * (c = Math.pow(2, -e)) < 1) {\n\t      e--;\n\t      c *= 2;\n\t    }\n\n\t    if (e + eBias >= 1) {\n\t      value += rt / c;\n\t    } else {\n\t      value += rt * Math.pow(2, 1 - eBias);\n\t    }\n\n\t    if (value * c >= 2) {\n\t      e++;\n\t      c /= 2;\n\t    }\n\n\t    if (e + eBias >= eMax) {\n\t      m = 0;\n\t      e = eMax;\n\t    } else if (e + eBias >= 1) {\n\t      m = (value * c - 1) * Math.pow(2, mLen);\n\t      e = e + eBias;\n\t    } else {\n\t      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n\t      e = 0;\n\t    }\n\t  }\n\n\t  if (isNaN(value)) m = 0;\n\n\t  while (mLen >= 8) {\n\t    buffer$$1[offset + i] = m & 0xff;\n\t    i += d;\n\t    m /= 256;\n\t    mLen -= 8;\n\t  }\n\n\t  e = e << mLen | m;\n\t  if (isNaN(value)) e += 8;\n\t  eLen += mLen;\n\n\t  while (eLen > 0) {\n\t    buffer$$1[offset + i] = e & 0xff;\n\t    i += d;\n\t    e /= 256;\n\t    eLen -= 8;\n\t  }\n\n\t  buffer$$1[offset + i - d] |= s * 128;\n\t}\n\n\tvar float_parser = {\n\t  readIEEE754: readIEEE754,\n\t  writeIEEE754: writeIEEE754\n\t};\n\n\tfunction _typeof$3(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$3(obj); }\n\n\tvar Buffer$5 = buffer.Buffer;\n\tvar writeIEEE754$1 = float_parser.writeIEEE754;\n\tvar normalizedFunctionString$1 = utils.normalizedFunctionString;\n\tvar regexp$1 = /\\x00/; // eslint-disable-line no-control-regex\n\n\tvar ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']); // To ensure that 0.4 of node works correctly\n\n\tvar isDate$1 = function isDate(d) {\n\t  return _typeof$3(d) === 'object' && Object.prototype.toString.call(d) === '[object Date]';\n\t};\n\n\tvar isRegExp$1 = function isRegExp(d) {\n\t  return Object.prototype.toString.call(d) === '[object RegExp]';\n\t};\n\n\tfunction serializeString(buffer$$1, key, value, index, isArray) {\n\t  // Encode String type\n\t  buffer$$1[index++] = constants.BSON_DATA_STRING; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes + 1;\n\t  buffer$$1[index - 1] = 0; // Write the string\n\n\t  var size = buffer$$1.write(value, index + 4, 'utf8'); // Write the size of the string to buffer\n\n\t  buffer$$1[index + 3] = size + 1 >> 24 & 0xff;\n\t  buffer$$1[index + 2] = size + 1 >> 16 & 0xff;\n\t  buffer$$1[index + 1] = size + 1 >> 8 & 0xff;\n\t  buffer$$1[index] = size + 1 & 0xff; // Update index\n\n\t  index = index + 4 + size; // Write zero\n\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeNumber(buffer$$1, key, value, index, isArray) {\n\t  // We have an integer value\n\t  if (Math.floor(value) === value && value >= constants.JS_INT_MIN && value <= constants.JS_INT_MAX) {\n\t    // If the value fits in 32 bits encode as int, if it fits in a double\n\t    // encode it as a double, otherwise long\n\t    if (value >= constants.BSON_INT32_MIN && value <= constants.BSON_INT32_MAX) {\n\t      // Set int type 32 bits or less\n\t      buffer$$1[index++] = constants.BSON_DATA_INT; // Number of written bytes\n\n\t      var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t      index = index + numberOfWrittenBytes;\n\t      buffer$$1[index++] = 0; // Write the int value\n\n\t      buffer$$1[index++] = value & 0xff;\n\t      buffer$$1[index++] = value >> 8 & 0xff;\n\t      buffer$$1[index++] = value >> 16 & 0xff;\n\t      buffer$$1[index++] = value >> 24 & 0xff;\n\t    } else if (value >= constants.JS_INT_MIN && value <= constants.JS_INT_MAX) {\n\t      // Encode as double\n\t      buffer$$1[index++] = constants.BSON_DATA_NUMBER; // Number of written bytes\n\n\t      var _numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t      index = index + _numberOfWrittenBytes;\n\t      buffer$$1[index++] = 0; // Write float\n\n\t      writeIEEE754$1(buffer$$1, value, index, 'little', 52, 8); // Ajust index\n\n\t      index = index + 8;\n\t    } else {\n\t      // Set long type\n\t      buffer$$1[index++] = constants.BSON_DATA_LONG; // Number of written bytes\n\n\t      var _numberOfWrittenBytes2 = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t      index = index + _numberOfWrittenBytes2;\n\t      buffer$$1[index++] = 0;\n\t      var longVal = long_1.fromNumber(value);\n\t      var lowBits = longVal.getLowBits();\n\t      var highBits = longVal.getHighBits(); // Encode low bits\n\n\t      buffer$$1[index++] = lowBits & 0xff;\n\t      buffer$$1[index++] = lowBits >> 8 & 0xff;\n\t      buffer$$1[index++] = lowBits >> 16 & 0xff;\n\t      buffer$$1[index++] = lowBits >> 24 & 0xff; // Encode high bits\n\n\t      buffer$$1[index++] = highBits & 0xff;\n\t      buffer$$1[index++] = highBits >> 8 & 0xff;\n\t      buffer$$1[index++] = highBits >> 16 & 0xff;\n\t      buffer$$1[index++] = highBits >> 24 & 0xff;\n\t    }\n\t  } else {\n\t    // Encode as double\n\t    buffer$$1[index++] = constants.BSON_DATA_NUMBER; // Number of written bytes\n\n\t    var _numberOfWrittenBytes3 = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t    index = index + _numberOfWrittenBytes3;\n\t    buffer$$1[index++] = 0; // Write float\n\n\t    writeIEEE754$1(buffer$$1, value, index, 'little', 52, 8); // Ajust index\n\n\t    index = index + 8;\n\t  }\n\n\t  return index;\n\t}\n\n\tfunction serializeNull(buffer$$1, key, value, index, isArray) {\n\t  // Set long type\n\t  buffer$$1[index++] = constants.BSON_DATA_NULL; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeBoolean(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_BOOLEAN; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Encode the boolean value\n\n\t  buffer$$1[index++] = value ? 1 : 0;\n\t  return index;\n\t}\n\n\tfunction serializeDate(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_DATE; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the date\n\n\t  var dateInMilis = long_1.fromNumber(value.getTime());\n\t  var lowBits = dateInMilis.getLowBits();\n\t  var highBits = dateInMilis.getHighBits(); // Encode low bits\n\n\t  buffer$$1[index++] = lowBits & 0xff;\n\t  buffer$$1[index++] = lowBits >> 8 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 16 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = highBits & 0xff;\n\t  buffer$$1[index++] = highBits >> 8 & 0xff;\n\t  buffer$$1[index++] = highBits >> 16 & 0xff;\n\t  buffer$$1[index++] = highBits >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tfunction serializeRegExp(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_REGEXP; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\n\t  if (value.source && value.source.match(regexp$1) != null) {\n\t    throw Error('value ' + value.source + ' must not contain null bytes');\n\t  } // Adjust the index\n\n\n\t  index = index + buffer$$1.write(value.source, index, 'utf8'); // Write zero\n\n\t  buffer$$1[index++] = 0x00; // Write the parameters\n\n\t  if (value.ignoreCase) buffer$$1[index++] = 0x69; // i\n\n\t  if (value.global) buffer$$1[index++] = 0x73; // s\n\n\t  if (value.multiline) buffer$$1[index++] = 0x6d; // m\n\t  // Add ending zero\n\n\t  buffer$$1[index++] = 0x00;\n\t  return index;\n\t}\n\n\tfunction serializeBSONRegExp(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_REGEXP; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Check the pattern for 0 bytes\n\n\t  if (value.pattern.match(regexp$1) != null) {\n\t    // The BSON spec doesn't allow keys with null bytes because keys are\n\t    // null-terminated.\n\t    throw Error('pattern ' + value.pattern + ' must not contain null bytes');\n\t  } // Adjust the index\n\n\n\t  index = index + buffer$$1.write(value.pattern, index, 'utf8'); // Write zero\n\n\t  buffer$$1[index++] = 0x00; // Write the options\n\n\t  index = index + buffer$$1.write(value.options.split('').sort().join(''), index, 'utf8'); // Add ending zero\n\n\t  buffer$$1[index++] = 0x00;\n\t  return index;\n\t}\n\n\tfunction serializeMinMax(buffer$$1, key, value, index, isArray) {\n\t  // Write the type of either min or max key\n\t  if (value === null) {\n\t    buffer$$1[index++] = constants.BSON_DATA_NULL;\n\t  } else if (value._bsontype === 'MinKey') {\n\t    buffer$$1[index++] = constants.BSON_DATA_MIN_KEY;\n\t  } else {\n\t    buffer$$1[index++] = constants.BSON_DATA_MAX_KEY;\n\t  } // Number of written bytes\n\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeObjectId(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_OID; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the objectId into the shared buffer\n\n\t  if (typeof value.id === 'string') {\n\t    buffer$$1.write(value.id, index, 'binary');\n\t  } else if (value.id && value.id.copy) {\n\t    value.id.copy(buffer$$1, index, 0, 12);\n\t  } else {\n\t    throw new TypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');\n\t  } // Ajust index\n\n\n\t  return index + 12;\n\t}\n\n\tfunction serializeBuffer(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_BINARY; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Get size of the buffer (current write point)\n\n\t  var size = value.length; // Write the size of the string to buffer\n\n\t  buffer$$1[index++] = size & 0xff;\n\t  buffer$$1[index++] = size >> 8 & 0xff;\n\t  buffer$$1[index++] = size >> 16 & 0xff;\n\t  buffer$$1[index++] = size >> 24 & 0xff; // Write the default subtype\n\n\t  buffer$$1[index++] = constants.BSON_BINARY_SUBTYPE_DEFAULT; // Copy the content form the binary field to the buffer\n\n\t  value.copy(buffer$$1, index, 0, size); // Adjust the index\n\n\t  index = index + size;\n\t  return index;\n\t}\n\n\tfunction serializeObject(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, isArray, path) {\n\t  for (var i = 0; i < path.length; i++) {\n\t    if (path[i] === value) throw new Error('cyclic dependency detected');\n\t  } // Push value to stack\n\n\n\t  path.push(value); // Write the type\n\n\t  buffer$$1[index++] = Array.isArray(value) ? constants.BSON_DATA_ARRAY : constants.BSON_DATA_OBJECT; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  var endIndex = serializeInto(buffer$$1, value, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined, path); // Pop stack\n\n\t  path.pop();\n\t  return endIndex;\n\t}\n\n\tfunction serializeDecimal128(buffer$$1, key, value, index, isArray) {\n\t  buffer$$1[index++] = constants.BSON_DATA_DECIMAL128; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the data from the value\n\n\t  value.bytes.copy(buffer$$1, index, 0, 16);\n\t  return index + 16;\n\t}\n\n\tfunction serializeLong(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = value._bsontype === 'Long' ? constants.BSON_DATA_LONG : constants.BSON_DATA_TIMESTAMP; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the date\n\n\t  var lowBits = value.getLowBits();\n\t  var highBits = value.getHighBits(); // Encode low bits\n\n\t  buffer$$1[index++] = lowBits & 0xff;\n\t  buffer$$1[index++] = lowBits >> 8 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 16 & 0xff;\n\t  buffer$$1[index++] = lowBits >> 24 & 0xff; // Encode high bits\n\n\t  buffer$$1[index++] = highBits & 0xff;\n\t  buffer$$1[index++] = highBits >> 8 & 0xff;\n\t  buffer$$1[index++] = highBits >> 16 & 0xff;\n\t  buffer$$1[index++] = highBits >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tfunction serializeInt32(buffer$$1, key, value, index, isArray) {\n\t  // Set int type 32 bits or less\n\t  buffer$$1[index++] = constants.BSON_DATA_INT; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the int value\n\n\t  buffer$$1[index++] = value & 0xff;\n\t  buffer$$1[index++] = value >> 8 & 0xff;\n\t  buffer$$1[index++] = value >> 16 & 0xff;\n\t  buffer$$1[index++] = value >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tfunction serializeDouble(buffer$$1, key, value, index, isArray) {\n\t  // Encode as double\n\t  buffer$$1[index++] = constants.BSON_DATA_NUMBER; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write float\n\n\t  writeIEEE754$1(buffer$$1, value.value, index, 'little', 52, 8); // Adjust index\n\n\t  index = index + 8;\n\t  return index;\n\t}\n\n\tfunction serializeFunction(buffer$$1, key, value, index, checkKeys, depth, isArray) {\n\t  buffer$$1[index++] = constants.BSON_DATA_CODE; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Function string\n\n\t  var functionString = normalizedFunctionString$1(value); // Write the string\n\n\t  var size = buffer$$1.write(functionString, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t  buffer$$1[index] = size & 0xff;\n\t  buffer$$1[index + 1] = size >> 8 & 0xff;\n\t  buffer$$1[index + 2] = size >> 16 & 0xff;\n\t  buffer$$1[index + 3] = size >> 24 & 0xff; // Update index\n\n\t  index = index + 4 + size - 1; // Write zero\n\n\t  buffer$$1[index++] = 0;\n\t  return index;\n\t}\n\n\tfunction serializeCode(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, isArray) {\n\t  if (value.scope && _typeof$3(value.scope) === 'object') {\n\t    // Write the type\n\t    buffer$$1[index++] = constants.BSON_DATA_CODE_W_SCOPE; // Number of written bytes\n\n\t    var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t    index = index + numberOfWrittenBytes;\n\t    buffer$$1[index++] = 0; // Starting index\n\n\t    var startIndex = index; // Serialize the function\n\t    // Get the function string\n\n\t    var functionString = typeof value.code === 'string' ? value.code : value.code.toString(); // Index adjustment\n\n\t    index = index + 4; // Write string into buffer\n\n\t    var codeSize = buffer$$1.write(functionString, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t    buffer$$1[index] = codeSize & 0xff;\n\t    buffer$$1[index + 1] = codeSize >> 8 & 0xff;\n\t    buffer$$1[index + 2] = codeSize >> 16 & 0xff;\n\t    buffer$$1[index + 3] = codeSize >> 24 & 0xff; // Write end 0\n\n\t    buffer$$1[index + 4 + codeSize - 1] = 0; // Write the\n\n\t    index = index + codeSize + 4; //\n\t    // Serialize the scope value\n\n\t    var endIndex = serializeInto(buffer$$1, value.scope, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined);\n\t    index = endIndex - 1; // Writ the total\n\n\t    var totalSize = endIndex - startIndex; // Write the total size of the object\n\n\t    buffer$$1[startIndex++] = totalSize & 0xff;\n\t    buffer$$1[startIndex++] = totalSize >> 8 & 0xff;\n\t    buffer$$1[startIndex++] = totalSize >> 16 & 0xff;\n\t    buffer$$1[startIndex++] = totalSize >> 24 & 0xff; // Write trailing zero\n\n\t    buffer$$1[index++] = 0;\n\t  } else {\n\t    buffer$$1[index++] = constants.BSON_DATA_CODE; // Number of written bytes\n\n\t    var _numberOfWrittenBytes4 = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\n\t    index = index + _numberOfWrittenBytes4;\n\t    buffer$$1[index++] = 0; // Function string\n\n\t    var _functionString = value.code.toString(); // Write the string\n\n\n\t    var size = buffer$$1.write(_functionString, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t    buffer$$1[index] = size & 0xff;\n\t    buffer$$1[index + 1] = size >> 8 & 0xff;\n\t    buffer$$1[index + 2] = size >> 16 & 0xff;\n\t    buffer$$1[index + 3] = size >> 24 & 0xff; // Update index\n\n\t    index = index + 4 + size - 1; // Write zero\n\n\t    buffer$$1[index++] = 0;\n\t  }\n\n\t  return index;\n\t}\n\n\tfunction serializeBinary(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_BINARY; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Extract the buffer\n\n\t  var data = value.value(true); // Calculate size\n\n\t  var size = value.position; // Add the deprecated 02 type 4 bytes of size to total\n\n\t  if (value.sub_type === binary.SUBTYPE_BYTE_ARRAY) size = size + 4; // Write the size of the string to buffer\n\n\t  buffer$$1[index++] = size & 0xff;\n\t  buffer$$1[index++] = size >> 8 & 0xff;\n\t  buffer$$1[index++] = size >> 16 & 0xff;\n\t  buffer$$1[index++] = size >> 24 & 0xff; // Write the subtype to the buffer\n\n\t  buffer$$1[index++] = value.sub_type; // If we have binary type 2 the 4 first bytes are the size\n\n\t  if (value.sub_type === binary.SUBTYPE_BYTE_ARRAY) {\n\t    size = size - 4;\n\t    buffer$$1[index++] = size & 0xff;\n\t    buffer$$1[index++] = size >> 8 & 0xff;\n\t    buffer$$1[index++] = size >> 16 & 0xff;\n\t    buffer$$1[index++] = size >> 24 & 0xff;\n\t  } // Write the data to the object\n\n\n\t  data.copy(buffer$$1, index, 0, value.position); // Adjust the index\n\n\t  index = index + value.position;\n\t  return index;\n\t}\n\n\tfunction serializeSymbol(buffer$$1, key, value, index, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_SYMBOL; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0; // Write the string\n\n\t  var size = buffer$$1.write(value.value, index + 4, 'utf8') + 1; // Write the size of the string to buffer\n\n\t  buffer$$1[index] = size & 0xff;\n\t  buffer$$1[index + 1] = size >> 8 & 0xff;\n\t  buffer$$1[index + 2] = size >> 16 & 0xff;\n\t  buffer$$1[index + 3] = size >> 24 & 0xff; // Update index\n\n\t  index = index + 4 + size - 1; // Write zero\n\n\t  buffer$$1[index++] = 0x00;\n\t  return index;\n\t}\n\n\tfunction serializeDBRef(buffer$$1, key, value, index, depth, serializeFunctions, isArray) {\n\t  // Write the type\n\t  buffer$$1[index++] = constants.BSON_DATA_OBJECT; // Number of written bytes\n\n\t  var numberOfWrittenBytes = !isArray ? buffer$$1.write(key, index, 'utf8') : buffer$$1.write(key, index, 'ascii'); // Encode the name\n\n\t  index = index + numberOfWrittenBytes;\n\t  buffer$$1[index++] = 0;\n\t  var startIndex = index;\n\t  var endIndex;\n\t  var output = {\n\t    $ref: value.collection || value.namespace,\n\t    // \"namespace\" was what library 1.x called \"collection\"\n\t    $id: value.oid\n\t  };\n\t  if (value.db != null) output.$db = value.db;\n\t  output = Object.assign(output, value.fields);\n\t  endIndex = serializeInto(buffer$$1, output, false, index, depth + 1, serializeFunctions); // Calculate object size\n\n\t  var size = endIndex - startIndex; // Write the size\n\n\t  buffer$$1[startIndex++] = size & 0xff;\n\t  buffer$$1[startIndex++] = size >> 8 & 0xff;\n\t  buffer$$1[startIndex++] = size >> 16 & 0xff;\n\t  buffer$$1[startIndex++] = size >> 24 & 0xff; // Set index\n\n\t  return endIndex;\n\t}\n\n\tfunction serializeInto(buffer$$1, object, checkKeys, startingIndex, depth, serializeFunctions, ignoreUndefined, path) {\n\t  startingIndex = startingIndex || 0;\n\t  path = path || []; // Push the object to the path\n\n\t  path.push(object); // Start place to serialize into\n\n\t  var index = startingIndex + 4; // Special case isArray\n\n\t  if (Array.isArray(object)) {\n\t    // Get object keys\n\t    for (var i = 0; i < object.length; i++) {\n\t      var key = '' + i;\n\t      var value = object[i]; // Is there an override value\n\n\t      if (value && value.toBSON) {\n\t        if (typeof value.toBSON !== 'function') throw new TypeError('toBSON is not a function');\n\t        value = value.toBSON();\n\t      }\n\n\t      var type = _typeof$3(value);\n\n\t      if (type === 'string') {\n\t        index = serializeString(buffer$$1, key, value, index, true);\n\t      } else if (type === 'number') {\n\t        index = serializeNumber(buffer$$1, key, value, index, true);\n\t      } else if (type === 'boolean') {\n\t        index = serializeBoolean(buffer$$1, key, value, index, true);\n\t      } else if (value instanceof Date || isDate$1(value)) {\n\t        index = serializeDate(buffer$$1, key, value, index, true);\n\t      } else if (value === undefined) {\n\t        index = serializeNull(buffer$$1, key, value, index, true);\n\t      } else if (value === null) {\n\t        index = serializeNull(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'ObjectId' || value['_bsontype'] === 'ObjectID') {\n\t        index = serializeObjectId(buffer$$1, key, value, index, true);\n\t      } else if (Buffer$5.isBuffer(value)) {\n\t        index = serializeBuffer(buffer$$1, key, value, index, true);\n\t      } else if (value instanceof RegExp || isRegExp$1(value)) {\n\t        index = serializeRegExp(buffer$$1, key, value, index, true);\n\t      } else if (type === 'object' && value['_bsontype'] == null) {\n\t        index = serializeObject(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, true, path);\n\t      } else if (type === 'object' && value['_bsontype'] === 'Decimal128') {\n\t        index = serializeDecimal128(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Long' || value['_bsontype'] === 'Timestamp') {\n\t        index = serializeLong(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Double') {\n\t        index = serializeDouble(buffer$$1, key, value, index, true);\n\t      } else if (typeof value === 'function' && serializeFunctions) {\n\t        index = serializeFunction(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, true);\n\t      } else if (value['_bsontype'] === 'Code') {\n\t        index = serializeCode(buffer$$1, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, true);\n\t      } else if (value['_bsontype'] === 'Binary') {\n\t        index = serializeBinary(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Symbol') {\n\t        index = serializeSymbol(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'DBRef') {\n\t        index = serializeDBRef(buffer$$1, key, value, index, depth, serializeFunctions, true);\n\t      } else if (value['_bsontype'] === 'BSONRegExp') {\n\t        index = serializeBSONRegExp(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'Int32') {\n\t        index = serializeInt32(buffer$$1, key, value, index, true);\n\t      } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {\n\t        index = serializeMinMax(buffer$$1, key, value, index, true);\n\t      } else if (typeof value['_bsontype'] !== 'undefined') {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);\n\t      }\n\t    }\n\t  } else if (object instanceof map) {\n\t    var iterator = object.entries();\n\t    var done = false;\n\n\t    while (!done) {\n\t      // Unpack the next entry\n\t      var entry = iterator.next();\n\t      done = entry.done; // Are we done, then skip and terminate\n\n\t      if (done) continue; // Get the entry values\n\n\t      var _key = entry.value[0];\n\t      var _value = entry.value[1]; // Check the type of the value\n\n\t      var _type = _typeof$3(_value); // Check the key and throw error if it's illegal\n\n\n\t      if (typeof _key === 'string' && !ignoreKeys.has(_key)) {\n\t        if (_key.match(regexp$1) != null) {\n\t          // The BSON spec doesn't allow keys with null bytes because keys are\n\t          // null-terminated.\n\t          throw Error('key ' + _key + ' must not contain null bytes');\n\t        }\n\n\t        if (checkKeys) {\n\t          if ('$' === _key[0]) {\n\t            throw Error('key ' + _key + \" must not start with '$'\");\n\t          } else if (~_key.indexOf('.')) {\n\t            throw Error('key ' + _key + \" must not contain '.'\");\n\t          }\n\t        }\n\t      }\n\n\t      if (_type === 'string') {\n\t        index = serializeString(buffer$$1, _key, _value, index);\n\t      } else if (_type === 'number') {\n\t        index = serializeNumber(buffer$$1, _key, _value, index);\n\t      } else if (_type === 'boolean') {\n\t        index = serializeBoolean(buffer$$1, _key, _value, index);\n\t      } else if (_value instanceof Date || isDate$1(_value)) {\n\t        index = serializeDate(buffer$$1, _key, _value, index);\n\t      } else if (_value === null || _value === undefined && ignoreUndefined === false) {\n\t        index = serializeNull(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'ObjectId' || _value['_bsontype'] === 'ObjectID') {\n\t        index = serializeObjectId(buffer$$1, _key, _value, index);\n\t      } else if (Buffer$5.isBuffer(_value)) {\n\t        index = serializeBuffer(buffer$$1, _key, _value, index);\n\t      } else if (_value instanceof RegExp || isRegExp$1(_value)) {\n\t        index = serializeRegExp(buffer$$1, _key, _value, index);\n\t      } else if (_type === 'object' && _value['_bsontype'] == null) {\n\t        index = serializeObject(buffer$$1, _key, _value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, false, path);\n\t      } else if (_type === 'object' && _value['_bsontype'] === 'Decimal128') {\n\t        index = serializeDecimal128(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Long' || _value['_bsontype'] === 'Timestamp') {\n\t        index = serializeLong(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Double') {\n\t        index = serializeDouble(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Code') {\n\t        index = serializeCode(buffer$$1, _key, _value, index, checkKeys, depth, serializeFunctions, ignoreUndefined);\n\t      } else if (typeof _value === 'function' && serializeFunctions) {\n\t        index = serializeFunction(buffer$$1, _key, _value, index, checkKeys, depth, serializeFunctions);\n\t      } else if (_value['_bsontype'] === 'Binary') {\n\t        index = serializeBinary(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Symbol') {\n\t        index = serializeSymbol(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'DBRef') {\n\t        index = serializeDBRef(buffer$$1, _key, _value, index, depth, serializeFunctions);\n\t      } else if (_value['_bsontype'] === 'BSONRegExp') {\n\t        index = serializeBSONRegExp(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'Int32') {\n\t        index = serializeInt32(buffer$$1, _key, _value, index);\n\t      } else if (_value['_bsontype'] === 'MinKey' || _value['_bsontype'] === 'MaxKey') {\n\t        index = serializeMinMax(buffer$$1, _key, _value, index);\n\t      } else if (typeof _value['_bsontype'] !== 'undefined') {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + _value['_bsontype']);\n\t      }\n\t    }\n\t  } else {\n\t    // Did we provide a custom serialization method\n\t    if (object.toBSON) {\n\t      if (typeof object.toBSON !== 'function') throw new TypeError('toBSON is not a function');\n\t      object = object.toBSON();\n\t      if (object != null && _typeof$3(object) !== 'object') throw new TypeError('toBSON function did not return an object');\n\t    } // Iterate over all the keys\n\n\n\t    for (var _key2 in object) {\n\t      var _value2 = object[_key2]; // Is there an override value\n\n\t      if (_value2 && _value2.toBSON) {\n\t        if (typeof _value2.toBSON !== 'function') throw new TypeError('toBSON is not a function');\n\t        _value2 = _value2.toBSON();\n\t      } // Check the type of the value\n\n\n\t      var _type2 = _typeof$3(_value2); // Check the key and throw error if it's illegal\n\n\n\t      if (typeof _key2 === 'string' && !ignoreKeys.has(_key2)) {\n\t        if (_key2.match(regexp$1) != null) {\n\t          // The BSON spec doesn't allow keys with null bytes because keys are\n\t          // null-terminated.\n\t          throw Error('key ' + _key2 + ' must not contain null bytes');\n\t        }\n\n\t        if (checkKeys) {\n\t          if ('$' === _key2[0]) {\n\t            throw Error('key ' + _key2 + \" must not start with '$'\");\n\t          } else if (~_key2.indexOf('.')) {\n\t            throw Error('key ' + _key2 + \" must not contain '.'\");\n\t          }\n\t        }\n\t      }\n\n\t      if (_type2 === 'string') {\n\t        index = serializeString(buffer$$1, _key2, _value2, index);\n\t      } else if (_type2 === 'number') {\n\t        index = serializeNumber(buffer$$1, _key2, _value2, index);\n\t      } else if (_type2 === 'boolean') {\n\t        index = serializeBoolean(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 instanceof Date || isDate$1(_value2)) {\n\t        index = serializeDate(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 === undefined) {\n\t        if (ignoreUndefined === false) index = serializeNull(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 === null) {\n\t        index = serializeNull(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'ObjectId' || _value2['_bsontype'] === 'ObjectID') {\n\t        index = serializeObjectId(buffer$$1, _key2, _value2, index);\n\t      } else if (Buffer$5.isBuffer(_value2)) {\n\t        index = serializeBuffer(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2 instanceof RegExp || isRegExp$1(_value2)) {\n\t        index = serializeRegExp(buffer$$1, _key2, _value2, index);\n\t      } else if (_type2 === 'object' && _value2['_bsontype'] == null) {\n\t        index = serializeObject(buffer$$1, _key2, _value2, index, checkKeys, depth, serializeFunctions, ignoreUndefined, false, path);\n\t      } else if (_type2 === 'object' && _value2['_bsontype'] === 'Decimal128') {\n\t        index = serializeDecimal128(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Long' || _value2['_bsontype'] === 'Timestamp') {\n\t        index = serializeLong(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Double') {\n\t        index = serializeDouble(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Code') {\n\t        index = serializeCode(buffer$$1, _key2, _value2, index, checkKeys, depth, serializeFunctions, ignoreUndefined);\n\t      } else if (typeof _value2 === 'function' && serializeFunctions) {\n\t        index = serializeFunction(buffer$$1, _key2, _value2, index, checkKeys, depth, serializeFunctions);\n\t      } else if (_value2['_bsontype'] === 'Binary') {\n\t        index = serializeBinary(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Symbol') {\n\t        index = serializeSymbol(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'DBRef') {\n\t        index = serializeDBRef(buffer$$1, _key2, _value2, index, depth, serializeFunctions);\n\t      } else if (_value2['_bsontype'] === 'BSONRegExp') {\n\t        index = serializeBSONRegExp(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'Int32') {\n\t        index = serializeInt32(buffer$$1, _key2, _value2, index);\n\t      } else if (_value2['_bsontype'] === 'MinKey' || _value2['_bsontype'] === 'MaxKey') {\n\t        index = serializeMinMax(buffer$$1, _key2, _value2, index);\n\t      } else if (typeof _value2['_bsontype'] !== 'undefined') {\n\t        throw new TypeError('Unrecognized or invalid _bsontype: ' + _value2['_bsontype']);\n\t      }\n\t    }\n\t  } // Remove the path\n\n\n\t  path.pop(); // Final padding byte for object\n\n\t  buffer$$1[index++] = 0x00; // Final size\n\n\t  var size = index - startingIndex; // Write the size of the object\n\n\t  buffer$$1[startingIndex++] = size & 0xff;\n\t  buffer$$1[startingIndex++] = size >> 8 & 0xff;\n\t  buffer$$1[startingIndex++] = size >> 16 & 0xff;\n\t  buffer$$1[startingIndex++] = size >> 24 & 0xff;\n\t  return index;\n\t}\n\n\tvar serializer = serializeInto;\n\n\tfunction _typeof$4(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$4 = function _typeof(obj) { return typeof obj; }; } else { _typeof$4 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$4(obj); }\n\n\tvar Buffer$6 = buffer.Buffer;\n\tvar normalizedFunctionString$2 = utils.normalizedFunctionString; // To ensure that 0.4 of node works correctly\n\n\tfunction isDate$2(d) {\n\t  return _typeof$4(d) === 'object' && Object.prototype.toString.call(d) === '[object Date]';\n\t}\n\n\tfunction calculateObjectSize(object, serializeFunctions, ignoreUndefined) {\n\t  var totalLength = 4 + 1;\n\n\t  if (Array.isArray(object)) {\n\t    for (var i = 0; i < object.length; i++) {\n\t      totalLength += calculateElement(i.toString(), object[i], serializeFunctions, true, ignoreUndefined);\n\t    }\n\t  } else {\n\t    // If we have toBSON defined, override the current object\n\t    if (object.toBSON) {\n\t      object = object.toBSON();\n\t    } // Calculate size\n\n\n\t    for (var key in object) {\n\t      totalLength += calculateElement(key, object[key], serializeFunctions, false, ignoreUndefined);\n\t    }\n\t  }\n\n\t  return totalLength;\n\t}\n\t/**\n\t * @ignore\n\t * @api private\n\t */\n\n\n\tfunction calculateElement(name, value, serializeFunctions, isArray, ignoreUndefined) {\n\t  // If we have toBSON defined, override the current object\n\t  if (value && value.toBSON) {\n\t    value = value.toBSON();\n\t  }\n\n\t  switch (_typeof$4(value)) {\n\t    case 'string':\n\t      return 1 + Buffer$6.byteLength(name, 'utf8') + 1 + 4 + Buffer$6.byteLength(value, 'utf8') + 1;\n\n\t    case 'number':\n\t      if (Math.floor(value) === value && value >= constants.JS_INT_MIN && value <= constants.JS_INT_MAX) {\n\t        if (value >= constants.BSON_INT32_MIN && value <= constants.BSON_INT32_MAX) {\n\t          // 32 bit\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (4 + 1);\n\t        } else {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t        }\n\t      } else {\n\t        // 64 bit\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t      }\n\n\t    case 'undefined':\n\t      if (isArray || !ignoreUndefined) return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1;\n\t      return 0;\n\n\t    case 'boolean':\n\t      return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (1 + 1);\n\n\t    case 'object':\n\t      if (value == null || value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1;\n\t      } else if (value['_bsontype'] === 'ObjectId' || value['_bsontype'] === 'ObjectID') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (12 + 1);\n\t      } else if (value instanceof Date || isDate$2(value)) {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t      } else if (typeof Buffer$6 !== 'undefined' && Buffer$6.isBuffer(value)) {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (1 + 4 + 1) + value.length;\n\t      } else if (value['_bsontype'] === 'Long' || value['_bsontype'] === 'Double' || value['_bsontype'] === 'Timestamp') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);\n\t      } else if (value['_bsontype'] === 'Decimal128') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (16 + 1);\n\t      } else if (value['_bsontype'] === 'Code') {\n\t        // Calculate size depending on the availability of a scope\n\t        if (value.scope != null && Object.keys(value.scope).length > 0) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + 4 + Buffer$6.byteLength(value.code.toString(), 'utf8') + 1 + calculateObjectSize(value.scope, serializeFunctions, ignoreUndefined);\n\t        } else {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + Buffer$6.byteLength(value.code.toString(), 'utf8') + 1;\n\t        }\n\t      } else if (value['_bsontype'] === 'Binary') {\n\t        // Check what kind of subtype we have\n\t        if (value.sub_type === binary.SUBTYPE_BYTE_ARRAY) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1 + 4);\n\t        } else {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1);\n\t        }\n\t      } else if (value['_bsontype'] === 'Symbol') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + Buffer$6.byteLength(value.value, 'utf8') + 4 + 1 + 1;\n\t      } else if (value['_bsontype'] === 'DBRef') {\n\t        // Set up correct object for serialization\n\t        var ordered_values = Object.assign({\n\t          $ref: value.collection,\n\t          $id: value.oid\n\t        }, value.fields); // Add db reference if it exists\n\n\t        if (value.db != null) {\n\t          ordered_values['$db'] = value.db;\n\t        }\n\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + calculateObjectSize(ordered_values, serializeFunctions, ignoreUndefined);\n\t      } else if (value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + Buffer$6.byteLength(value.source, 'utf8') + 1 + (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) + 1;\n\t      } else if (value['_bsontype'] === 'BSONRegExp') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + Buffer$6.byteLength(value.pattern, 'utf8') + 1 + Buffer$6.byteLength(value.options, 'utf8') + 1;\n\t      } else {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + calculateObjectSize(value, serializeFunctions, ignoreUndefined) + 1;\n\t      }\n\n\t    case 'function':\n\t      // WTF for 0.4.X where typeof /someregexp/ === 'function'\n\t      if (value instanceof RegExp || Object.prototype.toString.call(value) === '[object RegExp]' || String.call(value) === '[object RegExp]') {\n\t        return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + Buffer$6.byteLength(value.source, 'utf8') + 1 + (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) + 1;\n\t      } else {\n\t        if (serializeFunctions && value.scope != null && Object.keys(value.scope).length > 0) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + 4 + Buffer$6.byteLength(normalizedFunctionString$2(value), 'utf8') + 1 + calculateObjectSize(value.scope, serializeFunctions, ignoreUndefined);\n\t        } else if (serializeFunctions) {\n\t          return (name != null ? Buffer$6.byteLength(name, 'utf8') + 1 : 0) + 1 + 4 + Buffer$6.byteLength(normalizedFunctionString$2(value), 'utf8') + 1;\n\t        }\n\t      }\n\n\t  }\n\n\t  return 0;\n\t}\n\n\tvar calculate_size = calculateObjectSize;\n\n\tvar Buffer$7 = buffer.Buffer;\n\t/**\n\t * Makes sure that, if a Uint8Array is passed in, it is wrapped in a Buffer.\n\t *\n\t * @param {Buffer|Uint8Array} potentialBuffer The potential buffer\n\t * @returns {Buffer} the input if potentialBuffer is a buffer, or a buffer that\n\t * wraps a passed in Uint8Array\n\t * @throws {TypeError} If anything other than a Buffer or Uint8Array is passed in\n\t */\n\n\tvar ensure_buffer = function ensureBuffer(potentialBuffer) {\n\t  if (potentialBuffer instanceof Buffer$7) {\n\t    return potentialBuffer;\n\t  }\n\n\t  if (potentialBuffer instanceof Uint8Array) {\n\t    return Buffer$7.from(potentialBuffer.buffer);\n\t  }\n\n\t  throw new TypeError('Must use either Buffer or Uint8Array');\n\t};\n\n\tvar Buffer$8 = buffer.Buffer; // Parts of the parser\n\n\t/**\n\t * @ignore\n\t */\n\t// Default Max Size\n\n\tvar MAXSIZE = 1024 * 1024 * 17; // Current Internal Temporary Serialization Buffer\n\n\tvar buffer$1 = Buffer$8.alloc(MAXSIZE);\n\t/**\n\t * Sets the size of the internal serialization buffer.\n\t *\n\t * @method\n\t * @param {number} size The desired size for the internal serialization buffer\n\t */\n\n\tfunction setInternalBufferSize(size) {\n\t  // Resize the internal serialization buffer if needed\n\t  if (buffer$1.length < size) {\n\t    buffer$1 = Buffer$8.alloc(size);\n\t  }\n\t}\n\t/**\n\t * Serialize a Javascript object.\n\t *\n\t * @param {Object} object the Javascript object to serialize.\n\t * @param {Boolean} [options.checkKeys] the serializer will check if keys are valid.\n\t * @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.\n\t * @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.\n\t * @return {Buffer} returns the Buffer object containing the serialized object.\n\t */\n\n\n\tfunction serialize$1(object, options) {\n\t  options = options || {}; // Unpack the options\n\n\t  var checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;\n\t  var serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n\t  var ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n\t  var minInternalBufferSize = typeof options.minInternalBufferSize === 'number' ? options.minInternalBufferSize : MAXSIZE; // Resize the internal serialization buffer if needed\n\n\t  if (buffer$1.length < minInternalBufferSize) {\n\t    buffer$1 = Buffer$8.alloc(minInternalBufferSize);\n\t  } // Attempt to serialize\n\n\n\t  var serializationIndex = serializer(buffer$1, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined, []); // Create the final buffer\n\n\t  var finishedBuffer = Buffer$8.alloc(serializationIndex); // Copy into the finished buffer\n\n\t  buffer$1.copy(finishedBuffer, 0, 0, finishedBuffer.length); // Return the buffer\n\n\t  return finishedBuffer;\n\t}\n\t/**\n\t * Serialize a Javascript object using a predefined Buffer and index into the buffer, useful when pre-allocating the space for serialization.\n\t *\n\t * @param {Object} object the Javascript object to serialize.\n\t * @param {Buffer} buffer the Buffer you pre-allocated to store the serialized BSON object.\n\t * @param {Boolean} [options.checkKeys] the serializer will check if keys are valid.\n\t * @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.\n\t * @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.\n\t * @param {Number} [options.index] the index in the buffer where we wish to start serializing into.\n\t * @return {Number} returns the index pointing to the last written byte in the buffer.\n\t */\n\n\n\tfunction serializeWithBufferAndIndex(object, finalBuffer, options) {\n\t  options = options || {}; // Unpack the options\n\n\t  var checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;\n\t  var serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n\t  var ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n\t  var startIndex = typeof options.index === 'number' ? options.index : 0; // Attempt to serialize\n\n\t  var serializationIndex = serializer(buffer$1, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined);\n\t  buffer$1.copy(finalBuffer, startIndex, 0, serializationIndex); // Return the index\n\n\t  return startIndex + serializationIndex - 1;\n\t}\n\t/**\n\t * Deserialize data as BSON.\n\t *\n\t * @param {Buffer} buffer the buffer containing the serialized set of BSON documents.\n\t * @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.\n\t * @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.\n\t * @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.\n\t * @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits\n\t * @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a node.js Buffer instance.\n\t * @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.\n\t * @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.\n\t * @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.\n\t * @param {boolean} [options.allowObjectSmallerThanBufferSize=false] allows the buffer to be larger than the parsed BSON object\n\t * @return {Object} returns the deserialized Javascript Object.\n\t */\n\n\n\tfunction deserialize$2(buffer$$1, options) {\n\t  buffer$$1 = ensure_buffer(buffer$$1);\n\t  return deserializer(buffer$$1, options);\n\t}\n\t/**\n\t * Calculate the bson size for a passed in Javascript object.\n\t *\n\t * @param {Object} object the Javascript object to calculate the BSON byte size for.\n\t * @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.\n\t * @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.\n\t * @return {Number} returns the number of bytes the BSON object will take up.\n\t */\n\n\n\tfunction calculateObjectSize$1(object, options) {\n\t  options = options || {};\n\t  var serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n\t  var ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n\t  return calculate_size(object, serializeFunctions, ignoreUndefined);\n\t}\n\t/**\n\t * Deserialize stream data as BSON documents.\n\t *\n\t * @param {Buffer} data the buffer containing the serialized set of BSON documents.\n\t * @param {Number} startIndex the start index in the data Buffer where the deserialization is to start.\n\t * @param {Number} numberOfDocuments number of documents to deserialize.\n\t * @param {Array} documents an array where to store the deserialized documents.\n\t * @param {Number} docStartIndex the index in the documents array from where to start inserting documents.\n\t * @param {Object} [options] additional options used for the deserialization.\n\t * @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.\n\t * @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.\n\t * @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.\n\t * @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits\n\t * @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a node.js Buffer instance.\n\t * @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.\n\t * @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.\n\t * @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.\n\t * @return {Number} returns the next index in the buffer after deserialization **x** numbers of documents.\n\t */\n\n\n\tfunction deserializeStream(data, startIndex, numberOfDocuments, documents, docStartIndex, options) {\n\t  options = Object.assign({\n\t    allowObjectSmallerThanBufferSize: true\n\t  }, options);\n\t  data = ensure_buffer(data);\n\t  var index = startIndex; // Loop over all documents\n\n\t  for (var i = 0; i < numberOfDocuments; i++) {\n\t    // Find size of the document\n\t    var size = data[index] | data[index + 1] << 8 | data[index + 2] << 16 | data[index + 3] << 24; // Update options with index\n\n\t    options.index = index; // Parse the document at this point\n\n\t    documents[docStartIndex + i] = deserializer(data, options); // Adjust index by the document size\n\n\t    index = index + size;\n\t  } // Return object containing end index of parsing and list of documents\n\n\n\t  return index;\n\t}\n\n\tvar bson = {\n\t  // constants\n\t  // NOTE: this is done this way because rollup can't resolve an `Object.assign`ed export\n\t  BSON_INT32_MAX: constants.BSON_INT32_MAX,\n\t  BSON_INT32_MIN: constants.BSON_INT32_MIN,\n\t  BSON_INT64_MAX: constants.BSON_INT64_MAX,\n\t  BSON_INT64_MIN: constants.BSON_INT64_MIN,\n\t  JS_INT_MAX: constants.JS_INT_MAX,\n\t  JS_INT_MIN: constants.JS_INT_MIN,\n\t  BSON_DATA_NUMBER: constants.BSON_DATA_NUMBER,\n\t  BSON_DATA_STRING: constants.BSON_DATA_STRING,\n\t  BSON_DATA_OBJECT: constants.BSON_DATA_OBJECT,\n\t  BSON_DATA_ARRAY: constants.BSON_DATA_ARRAY,\n\t  BSON_DATA_BINARY: constants.BSON_DATA_BINARY,\n\t  BSON_DATA_UNDEFINED: constants.BSON_DATA_UNDEFINED,\n\t  BSON_DATA_OID: constants.BSON_DATA_OID,\n\t  BSON_DATA_BOOLEAN: constants.BSON_DATA_BOOLEAN,\n\t  BSON_DATA_DATE: constants.BSON_DATA_DATE,\n\t  BSON_DATA_NULL: constants.BSON_DATA_NULL,\n\t  BSON_DATA_REGEXP: constants.BSON_DATA_REGEXP,\n\t  BSON_DATA_DBPOINTER: constants.BSON_DATA_DBPOINTER,\n\t  BSON_DATA_CODE: constants.BSON_DATA_CODE,\n\t  BSON_DATA_SYMBOL: constants.BSON_DATA_SYMBOL,\n\t  BSON_DATA_CODE_W_SCOPE: constants.BSON_DATA_CODE_W_SCOPE,\n\t  BSON_DATA_INT: constants.BSON_DATA_INT,\n\t  BSON_DATA_TIMESTAMP: constants.BSON_DATA_TIMESTAMP,\n\t  BSON_DATA_LONG: constants.BSON_DATA_LONG,\n\t  BSON_DATA_DECIMAL128: constants.BSON_DATA_DECIMAL128,\n\t  BSON_DATA_MIN_KEY: constants.BSON_DATA_MIN_KEY,\n\t  BSON_DATA_MAX_KEY: constants.BSON_DATA_MAX_KEY,\n\t  BSON_BINARY_SUBTYPE_DEFAULT: constants.BSON_BINARY_SUBTYPE_DEFAULT,\n\t  BSON_BINARY_SUBTYPE_FUNCTION: constants.BSON_BINARY_SUBTYPE_FUNCTION,\n\t  BSON_BINARY_SUBTYPE_BYTE_ARRAY: constants.BSON_BINARY_SUBTYPE_BYTE_ARRAY,\n\t  BSON_BINARY_SUBTYPE_UUID: constants.BSON_BINARY_SUBTYPE_UUID,\n\t  BSON_BINARY_SUBTYPE_MD5: constants.BSON_BINARY_SUBTYPE_MD5,\n\t  BSON_BINARY_SUBTYPE_USER_DEFINED: constants.BSON_BINARY_SUBTYPE_USER_DEFINED,\n\t  // wrapped types\n\t  Code: code,\n\t  Map: map,\n\t  BSONSymbol: symbol,\n\t  DBRef: db_ref,\n\t  Binary: binary,\n\t  ObjectId: objectid,\n\t  Long: long_1,\n\t  Timestamp: timestamp,\n\t  Double: double_1,\n\t  Int32: int_32,\n\t  MinKey: min_key,\n\t  MaxKey: max_key,\n\t  BSONRegExp: regexp,\n\t  Decimal128: decimal128,\n\t  // methods\n\t  serialize: serialize$1,\n\t  serializeWithBufferAndIndex: serializeWithBufferAndIndex,\n\t  deserialize: deserialize$2,\n\t  calculateObjectSize: calculateObjectSize$1,\n\t  deserializeStream: deserializeStream,\n\t  setInternalBufferSize: setInternalBufferSize,\n\t  // legacy support\n\t  ObjectID: objectid,\n\t  // Extended JSON\n\t  EJSON: extended_json\n\t};\n\tvar bson_1 = bson.BSON_INT32_MAX;\n\tvar bson_2 = bson.BSON_INT32_MIN;\n\tvar bson_3 = bson.BSON_INT64_MAX;\n\tvar bson_4 = bson.BSON_INT64_MIN;\n\tvar bson_5 = bson.JS_INT_MAX;\n\tvar bson_6 = bson.JS_INT_MIN;\n\tvar bson_7 = bson.BSON_DATA_NUMBER;\n\tvar bson_8 = bson.BSON_DATA_STRING;\n\tvar bson_9 = bson.BSON_DATA_OBJECT;\n\tvar bson_10 = bson.BSON_DATA_ARRAY;\n\tvar bson_11 = bson.BSON_DATA_BINARY;\n\tvar bson_12 = bson.BSON_DATA_UNDEFINED;\n\tvar bson_13 = bson.BSON_DATA_OID;\n\tvar bson_14 = bson.BSON_DATA_BOOLEAN;\n\tvar bson_15 = bson.BSON_DATA_DATE;\n\tvar bson_16 = bson.BSON_DATA_NULL;\n\tvar bson_17 = bson.BSON_DATA_REGEXP;\n\tvar bson_18 = bson.BSON_DATA_DBPOINTER;\n\tvar bson_19 = bson.BSON_DATA_CODE;\n\tvar bson_20 = bson.BSON_DATA_SYMBOL;\n\tvar bson_21 = bson.BSON_DATA_CODE_W_SCOPE;\n\tvar bson_22 = bson.BSON_DATA_INT;\n\tvar bson_23 = bson.BSON_DATA_TIMESTAMP;\n\tvar bson_24 = bson.BSON_DATA_LONG;\n\tvar bson_25 = bson.BSON_DATA_DECIMAL128;\n\tvar bson_26 = bson.BSON_DATA_MIN_KEY;\n\tvar bson_27 = bson.BSON_DATA_MAX_KEY;\n\tvar bson_28 = bson.BSON_BINARY_SUBTYPE_DEFAULT;\n\tvar bson_29 = bson.BSON_BINARY_SUBTYPE_FUNCTION;\n\tvar bson_30 = bson.BSON_BINARY_SUBTYPE_BYTE_ARRAY;\n\tvar bson_31 = bson.BSON_BINARY_SUBTYPE_UUID;\n\tvar bson_32 = bson.BSON_BINARY_SUBTYPE_MD5;\n\tvar bson_33 = bson.BSON_BINARY_SUBTYPE_USER_DEFINED;\n\tvar bson_34 = bson.Code;\n\tvar bson_35 = bson.BSONSymbol;\n\tvar bson_36 = bson.DBRef;\n\tvar bson_37 = bson.Binary;\n\tvar bson_38 = bson.ObjectId;\n\tvar bson_39 = bson.Long;\n\tvar bson_40 = bson.Timestamp;\n\tvar bson_41 = bson.Double;\n\tvar bson_42 = bson.Int32;\n\tvar bson_43 = bson.MinKey;\n\tvar bson_44 = bson.MaxKey;\n\tvar bson_45 = bson.BSONRegExp;\n\tvar bson_46 = bson.Decimal128;\n\tvar bson_47 = bson.serialize;\n\tvar bson_48 = bson.serializeWithBufferAndIndex;\n\tvar bson_49 = bson.deserialize;\n\tvar bson_50 = bson.calculateObjectSize;\n\tvar bson_51 = bson.deserializeStream;\n\tvar bson_52 = bson.setInternalBufferSize;\n\tvar bson_53 = bson.ObjectID;\n\tvar bson_54 = bson.EJSON;\n\n\texports.default = bson;\n\texports.BSON_INT32_MAX = bson_1;\n\texports.BSON_INT32_MIN = bson_2;\n\texports.BSON_INT64_MAX = bson_3;\n\texports.BSON_INT64_MIN = bson_4;\n\texports.JS_INT_MAX = bson_5;\n\texports.JS_INT_MIN = bson_6;\n\texports.BSON_DATA_NUMBER = bson_7;\n\texports.BSON_DATA_STRING = bson_8;\n\texports.BSON_DATA_OBJECT = bson_9;\n\texports.BSON_DATA_ARRAY = bson_10;\n\texports.BSON_DATA_BINARY = bson_11;\n\texports.BSON_DATA_UNDEFINED = bson_12;\n\texports.BSON_DATA_OID = bson_13;\n\texports.BSON_DATA_BOOLEAN = bson_14;\n\texports.BSON_DATA_DATE = bson_15;\n\texports.BSON_DATA_NULL = bson_16;\n\texports.BSON_DATA_REGEXP = bson_17;\n\texports.BSON_DATA_DBPOINTER = bson_18;\n\texports.BSON_DATA_CODE = bson_19;\n\texports.BSON_DATA_SYMBOL = bson_20;\n\texports.BSON_DATA_CODE_W_SCOPE = bson_21;\n\texports.BSON_DATA_INT = bson_22;\n\texports.BSON_DATA_TIMESTAMP = bson_23;\n\texports.BSON_DATA_LONG = bson_24;\n\texports.BSON_DATA_DECIMAL128 = bson_25;\n\texports.BSON_DATA_MIN_KEY = bson_26;\n\texports.BSON_DATA_MAX_KEY = bson_27;\n\texports.BSON_BINARY_SUBTYPE_DEFAULT = bson_28;\n\texports.BSON_BINARY_SUBTYPE_FUNCTION = bson_29;\n\texports.BSON_BINARY_SUBTYPE_BYTE_ARRAY = bson_30;\n\texports.BSON_BINARY_SUBTYPE_UUID = bson_31;\n\texports.BSON_BINARY_SUBTYPE_MD5 = bson_32;\n\texports.BSON_BINARY_SUBTYPE_USER_DEFINED = bson_33;\n\texports.Code = bson_34;\n\texports.BSONSymbol = bson_35;\n\texports.DBRef = bson_36;\n\texports.Binary = bson_37;\n\texports.ObjectId = bson_38;\n\texports.Long = bson_39;\n\texports.Timestamp = bson_40;\n\texports.Double = bson_41;\n\texports.Int32 = bson_42;\n\texports.MinKey = bson_43;\n\texports.MaxKey = bson_44;\n\texports.BSONRegExp = bson_45;\n\texports.Decimal128 = bson_46;\n\texports.serialize = bson_47;\n\texports.serializeWithBufferAndIndex = bson_48;\n\texports.deserialize = bson_49;\n\texports.calculateObjectSize = bson_50;\n\texports.deserializeStream = bson_51;\n\texports.setInternalBufferSize = bson_52;\n\texports.ObjectID = bson_53;\n\texports.EJSON = bson_54;\n\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(1).Buffer))\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports) {\n\nmodule.exports = Long;\r\n\r\n/**\r\n * wasm optimizations, to do native i64 multiplication and divide\r\n */\r\nvar wasm = null;\r\n\r\ntry {\r\n  wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([\r\n    0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11\r\n  ])), {}).exports;\r\n} catch (e) {\r\n  // no wasm support :(\r\n}\r\n\r\n/**\r\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\r\n *  See the from* functions below for more convenient ways of constructing Longs.\r\n * @exports Long\r\n * @class A Long class for representing a 64 bit two's-complement integer value.\r\n * @param {number} low The low (signed) 32 bits of the long\r\n * @param {number} high The high (signed) 32 bits of the long\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @constructor\r\n */\r\nfunction Long(low, high, unsigned) {\r\n\r\n    /**\r\n     * The low 32 bits as a signed value.\r\n     * @type {number}\r\n     */\r\n    this.low = low | 0;\r\n\r\n    /**\r\n     * The high 32 bits as a signed value.\r\n     * @type {number}\r\n     */\r\n    this.high = high | 0;\r\n\r\n    /**\r\n     * Whether unsigned or not.\r\n     * @type {boolean}\r\n     */\r\n    this.unsigned = !!unsigned;\r\n}\r\n\r\n// The internal representation of a long is the two given signed, 32-bit values.\r\n// We use 32-bit pieces because these are the size of integers on which\r\n// Javascript performs bit-operations.  For operations like addition and\r\n// multiplication, we split each number into 16 bit pieces, which can easily be\r\n// multiplied within Javascript's floating-point representation without overflow\r\n// or change in sign.\r\n//\r\n// In the algorithms below, we frequently reduce the negative case to the\r\n// positive case by negating the input(s) and then post-processing the result.\r\n// Note that we must ALWAYS check specially whether those values are MIN_VALUE\r\n// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\r\n// a positive number, it overflows back into a negative).  Not handling this\r\n// case would often result in infinite recursion.\r\n//\r\n// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\r\n// methods on which they depend.\r\n\r\n/**\r\n * An indicator used to reliably determine if an object is a Long or not.\r\n * @type {boolean}\r\n * @const\r\n * @private\r\n */\r\nLong.prototype.__isLong__;\r\n\r\nObject.defineProperty(Long.prototype, \"__isLong__\", { value: true });\r\n\r\n/**\r\n * @function\r\n * @param {*} obj Object\r\n * @returns {boolean}\r\n * @inner\r\n */\r\nfunction isLong(obj) {\r\n    return (obj && obj[\"__isLong__\"]) === true;\r\n}\r\n\r\n/**\r\n * Tests if the specified object is a Long.\r\n * @function\r\n * @param {*} obj Object\r\n * @returns {boolean}\r\n */\r\nLong.isLong = isLong;\r\n\r\n/**\r\n * A cache of the Long representations of small integer values.\r\n * @type {!Object}\r\n * @inner\r\n */\r\nvar INT_CACHE = {};\r\n\r\n/**\r\n * A cache of the Long representations of small unsigned integer values.\r\n * @type {!Object}\r\n * @inner\r\n */\r\nvar UINT_CACHE = {};\r\n\r\n/**\r\n * @param {number} value\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromInt(value, unsigned) {\r\n    var obj, cachedObj, cache;\r\n    if (unsigned) {\r\n        value >>>= 0;\r\n        if (cache = (0 <= value && value < 256)) {\r\n            cachedObj = UINT_CACHE[value];\r\n            if (cachedObj)\r\n                return cachedObj;\r\n        }\r\n        obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\r\n        if (cache)\r\n            UINT_CACHE[value] = obj;\r\n        return obj;\r\n    } else {\r\n        value |= 0;\r\n        if (cache = (-128 <= value && value < 128)) {\r\n            cachedObj = INT_CACHE[value];\r\n            if (cachedObj)\r\n                return cachedObj;\r\n        }\r\n        obj = fromBits(value, value < 0 ? -1 : 0, false);\r\n        if (cache)\r\n            INT_CACHE[value] = obj;\r\n        return obj;\r\n    }\r\n}\r\n\r\n/**\r\n * Returns a Long representing the given 32 bit integer value.\r\n * @function\r\n * @param {number} value The 32 bit integer in question\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromInt = fromInt;\r\n\r\n/**\r\n * @param {number} value\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromNumber(value, unsigned) {\r\n    if (isNaN(value))\r\n        return unsigned ? UZERO : ZERO;\r\n    if (unsigned) {\r\n        if (value < 0)\r\n            return UZERO;\r\n        if (value >= TWO_PWR_64_DBL)\r\n            return MAX_UNSIGNED_VALUE;\r\n    } else {\r\n        if (value <= -TWO_PWR_63_DBL)\r\n            return MIN_VALUE;\r\n        if (value + 1 >= TWO_PWR_63_DBL)\r\n            return MAX_VALUE;\r\n    }\r\n    if (value < 0)\r\n        return fromNumber(-value, unsigned).neg();\r\n    return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\r\n}\r\n\r\n/**\r\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\r\n * @function\r\n * @param {number} value The number in question\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromNumber = fromNumber;\r\n\r\n/**\r\n * @param {number} lowBits\r\n * @param {number} highBits\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromBits(lowBits, highBits, unsigned) {\r\n    return new Long(lowBits, highBits, unsigned);\r\n}\r\n\r\n/**\r\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\r\n *  assumed to use 32 bits.\r\n * @function\r\n * @param {number} lowBits The low 32 bits\r\n * @param {number} highBits The high 32 bits\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromBits = fromBits;\r\n\r\n/**\r\n * @function\r\n * @param {number} base\r\n * @param {number} exponent\r\n * @returns {number}\r\n * @inner\r\n */\r\nvar pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\r\n\r\n/**\r\n * @param {string} str\r\n * @param {(boolean|number)=} unsigned\r\n * @param {number=} radix\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromString(str, unsigned, radix) {\r\n    if (str.length === 0)\r\n        throw Error('empty string');\r\n    if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\r\n        return ZERO;\r\n    if (typeof unsigned === 'number') {\r\n        // For goog.math.long compatibility\r\n        radix = unsigned,\r\n        unsigned = false;\r\n    } else {\r\n        unsigned = !! unsigned;\r\n    }\r\n    radix = radix || 10;\r\n    if (radix < 2 || 36 < radix)\r\n        throw RangeError('radix');\r\n\r\n    var p;\r\n    if ((p = str.indexOf('-')) > 0)\r\n        throw Error('interior hyphen');\r\n    else if (p === 0) {\r\n        return fromString(str.substring(1), unsigned, radix).neg();\r\n    }\r\n\r\n    // Do several (8) digits each time through the loop, so as to\r\n    // minimize the calls to the very expensive emulated div.\r\n    var radixToPower = fromNumber(pow_dbl(radix, 8));\r\n\r\n    var result = ZERO;\r\n    for (var i = 0; i < str.length; i += 8) {\r\n        var size = Math.min(8, str.length - i),\r\n            value = parseInt(str.substring(i, i + size), radix);\r\n        if (size < 8) {\r\n            var power = fromNumber(pow_dbl(radix, size));\r\n            result = result.mul(power).add(fromNumber(value));\r\n        } else {\r\n            result = result.mul(radixToPower);\r\n            result = result.add(fromNumber(value));\r\n        }\r\n    }\r\n    result.unsigned = unsigned;\r\n    return result;\r\n}\r\n\r\n/**\r\n * Returns a Long representation of the given string, written using the specified radix.\r\n * @function\r\n * @param {string} str The textual representation of the Long\r\n * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\r\n * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\r\n * @returns {!Long} The corresponding Long value\r\n */\r\nLong.fromString = fromString;\r\n\r\n/**\r\n * @function\r\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\r\n * @param {boolean=} unsigned\r\n * @returns {!Long}\r\n * @inner\r\n */\r\nfunction fromValue(val, unsigned) {\r\n    if (typeof val === 'number')\r\n        return fromNumber(val, unsigned);\r\n    if (typeof val === 'string')\r\n        return fromString(val, unsigned);\r\n    // Throws for non-objects, converts non-instanceof Long:\r\n    return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);\r\n}\r\n\r\n/**\r\n * Converts the specified value to a Long using the appropriate from* function for its type.\r\n * @function\r\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {!Long}\r\n */\r\nLong.fromValue = fromValue;\r\n\r\n// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\r\n// no runtime penalty for these.\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_16_DBL = 1 << 16;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_24_DBL = 1 << 24;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\r\n\r\n/**\r\n * @type {number}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\r\n\r\n/**\r\n * @type {!Long}\r\n * @const\r\n * @inner\r\n */\r\nvar TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar ZERO = fromInt(0);\r\n\r\n/**\r\n * Signed zero.\r\n * @type {!Long}\r\n */\r\nLong.ZERO = ZERO;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar UZERO = fromInt(0, true);\r\n\r\n/**\r\n * Unsigned zero.\r\n * @type {!Long}\r\n */\r\nLong.UZERO = UZERO;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar ONE = fromInt(1);\r\n\r\n/**\r\n * Signed one.\r\n * @type {!Long}\r\n */\r\nLong.ONE = ONE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar UONE = fromInt(1, true);\r\n\r\n/**\r\n * Unsigned one.\r\n * @type {!Long}\r\n */\r\nLong.UONE = UONE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar NEG_ONE = fromInt(-1);\r\n\r\n/**\r\n * Signed negative one.\r\n * @type {!Long}\r\n */\r\nLong.NEG_ONE = NEG_ONE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);\r\n\r\n/**\r\n * Maximum signed value.\r\n * @type {!Long}\r\n */\r\nLong.MAX_VALUE = MAX_VALUE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);\r\n\r\n/**\r\n * Maximum unsigned value.\r\n * @type {!Long}\r\n */\r\nLong.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\r\n\r\n/**\r\n * @type {!Long}\r\n * @inner\r\n */\r\nvar MIN_VALUE = fromBits(0, 0x80000000|0, false);\r\n\r\n/**\r\n * Minimum signed value.\r\n * @type {!Long}\r\n */\r\nLong.MIN_VALUE = MIN_VALUE;\r\n\r\n/**\r\n * @alias Long.prototype\r\n * @inner\r\n */\r\nvar LongPrototype = Long.prototype;\r\n\r\n/**\r\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\r\n * @returns {number}\r\n */\r\nLongPrototype.toInt = function toInt() {\r\n    return this.unsigned ? this.low >>> 0 : this.low;\r\n};\r\n\r\n/**\r\n * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\r\n * @returns {number}\r\n */\r\nLongPrototype.toNumber = function toNumber() {\r\n    if (this.unsigned)\r\n        return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);\r\n    return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\r\n};\r\n\r\n/**\r\n * Converts the Long to a string written in the specified radix.\r\n * @param {number=} radix Radix (2-36), defaults to 10\r\n * @returns {string}\r\n * @override\r\n * @throws {RangeError} If `radix` is out of range\r\n */\r\nLongPrototype.toString = function toString(radix) {\r\n    radix = radix || 10;\r\n    if (radix < 2 || 36 < radix)\r\n        throw RangeError('radix');\r\n    if (this.isZero())\r\n        return '0';\r\n    if (this.isNegative()) { // Unsigned Longs are never negative\r\n        if (this.eq(MIN_VALUE)) {\r\n            // We need to change the Long value before it can be negated, so we remove\r\n            // the bottom-most digit in this base and then recurse to do the rest.\r\n            var radixLong = fromNumber(radix),\r\n                div = this.div(radixLong),\r\n                rem1 = div.mul(radixLong).sub(this);\r\n            return div.toString(radix) + rem1.toInt().toString(radix);\r\n        } else\r\n            return '-' + this.neg().toString(radix);\r\n    }\r\n\r\n    // Do several (6) digits each time through the loop, so as to\r\n    // minimize the calls to the very expensive emulated div.\r\n    var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\r\n        rem = this;\r\n    var result = '';\r\n    while (true) {\r\n        var remDiv = rem.div(radixToPower),\r\n            intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\r\n            digits = intval.toString(radix);\r\n        rem = remDiv;\r\n        if (rem.isZero())\r\n            return digits + result;\r\n        else {\r\n            while (digits.length < 6)\r\n                digits = '0' + digits;\r\n            result = '' + digits + result;\r\n        }\r\n    }\r\n};\r\n\r\n/**\r\n * Gets the high 32 bits as a signed integer.\r\n * @returns {number} Signed high bits\r\n */\r\nLongPrototype.getHighBits = function getHighBits() {\r\n    return this.high;\r\n};\r\n\r\n/**\r\n * Gets the high 32 bits as an unsigned integer.\r\n * @returns {number} Unsigned high bits\r\n */\r\nLongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\r\n    return this.high >>> 0;\r\n};\r\n\r\n/**\r\n * Gets the low 32 bits as a signed integer.\r\n * @returns {number} Signed low bits\r\n */\r\nLongPrototype.getLowBits = function getLowBits() {\r\n    return this.low;\r\n};\r\n\r\n/**\r\n * Gets the low 32 bits as an unsigned integer.\r\n * @returns {number} Unsigned low bits\r\n */\r\nLongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\r\n    return this.low >>> 0;\r\n};\r\n\r\n/**\r\n * Gets the number of bits needed to represent the absolute value of this Long.\r\n * @returns {number}\r\n */\r\nLongPrototype.getNumBitsAbs = function getNumBitsAbs() {\r\n    if (this.isNegative()) // Unsigned Longs are never negative\r\n        return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\r\n    var val = this.high != 0 ? this.high : this.low;\r\n    for (var bit = 31; bit > 0; bit--)\r\n        if ((val & (1 << bit)) != 0)\r\n            break;\r\n    return this.high != 0 ? bit + 33 : bit + 1;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals zero.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isZero = function isZero() {\r\n    return this.high === 0 && this.low === 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.eqz = LongPrototype.isZero;\r\n\r\n/**\r\n * Tests if this Long's value is negative.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isNegative = function isNegative() {\r\n    return !this.unsigned && this.high < 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is positive.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isPositive = function isPositive() {\r\n    return this.unsigned || this.high >= 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is odd.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isOdd = function isOdd() {\r\n    return (this.low & 1) === 1;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is even.\r\n * @returns {boolean}\r\n */\r\nLongPrototype.isEven = function isEven() {\r\n    return (this.low & 1) === 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.equals = function equals(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)\r\n        return false;\r\n    return this.high === other.high && this.low === other.low;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.eq = LongPrototype.equals;\r\n\r\n/**\r\n * Tests if this Long's value differs from the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.notEquals = function notEquals(other) {\r\n    return !this.eq(/* validates */ other);\r\n};\r\n\r\n/**\r\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.neq = LongPrototype.notEquals;\r\n\r\n/**\r\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.ne = LongPrototype.notEquals;\r\n\r\n/**\r\n * Tests if this Long's value is less than the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lessThan = function lessThan(other) {\r\n    return this.comp(/* validates */ other) < 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lt = LongPrototype.lessThan;\r\n\r\n/**\r\n * Tests if this Long's value is less than or equal the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\r\n    return this.comp(/* validates */ other) <= 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.lte = LongPrototype.lessThanOrEqual;\r\n\r\n/**\r\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.le = LongPrototype.lessThanOrEqual;\r\n\r\n/**\r\n * Tests if this Long's value is greater than the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.greaterThan = function greaterThan(other) {\r\n    return this.comp(/* validates */ other) > 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.gt = LongPrototype.greaterThan;\r\n\r\n/**\r\n * Tests if this Long's value is greater than or equal the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\r\n    return this.comp(/* validates */ other) >= 0;\r\n};\r\n\r\n/**\r\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.gte = LongPrototype.greaterThanOrEqual;\r\n\r\n/**\r\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {boolean}\r\n */\r\nLongPrototype.ge = LongPrototype.greaterThanOrEqual;\r\n\r\n/**\r\n * Compares this Long's value with the specified's.\r\n * @param {!Long|number|string} other Other value\r\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n *  if the given one is greater\r\n */\r\nLongPrototype.compare = function compare(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    if (this.eq(other))\r\n        return 0;\r\n    var thisNeg = this.isNegative(),\r\n        otherNeg = other.isNegative();\r\n    if (thisNeg && !otherNeg)\r\n        return -1;\r\n    if (!thisNeg && otherNeg)\r\n        return 1;\r\n    // At this point the sign bits are the same\r\n    if (!this.unsigned)\r\n        return this.sub(other).isNegative() ? -1 : 1;\r\n    // Both are positive if at least one is unsigned\r\n    return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;\r\n};\r\n\r\n/**\r\n * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\r\n * @function\r\n * @param {!Long|number|string} other Other value\r\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n *  if the given one is greater\r\n */\r\nLongPrototype.comp = LongPrototype.compare;\r\n\r\n/**\r\n * Negates this Long's value.\r\n * @returns {!Long} Negated Long\r\n */\r\nLongPrototype.negate = function negate() {\r\n    if (!this.unsigned && this.eq(MIN_VALUE))\r\n        return MIN_VALUE;\r\n    return this.not().add(ONE);\r\n};\r\n\r\n/**\r\n * Negates this Long's value. This is an alias of {@link Long#negate}.\r\n * @function\r\n * @returns {!Long} Negated Long\r\n */\r\nLongPrototype.neg = LongPrototype.negate;\r\n\r\n/**\r\n * Returns the sum of this and the specified Long.\r\n * @param {!Long|number|string} addend Addend\r\n * @returns {!Long} Sum\r\n */\r\nLongPrototype.add = function add(addend) {\r\n    if (!isLong(addend))\r\n        addend = fromValue(addend);\r\n\r\n    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\r\n\r\n    var a48 = this.high >>> 16;\r\n    var a32 = this.high & 0xFFFF;\r\n    var a16 = this.low >>> 16;\r\n    var a00 = this.low & 0xFFFF;\r\n\r\n    var b48 = addend.high >>> 16;\r\n    var b32 = addend.high & 0xFFFF;\r\n    var b16 = addend.low >>> 16;\r\n    var b00 = addend.low & 0xFFFF;\r\n\r\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n    c00 += a00 + b00;\r\n    c16 += c00 >>> 16;\r\n    c00 &= 0xFFFF;\r\n    c16 += a16 + b16;\r\n    c32 += c16 >>> 16;\r\n    c16 &= 0xFFFF;\r\n    c32 += a32 + b32;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c48 += a48 + b48;\r\n    c48 &= 0xFFFF;\r\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the difference of this and the specified Long.\r\n * @param {!Long|number|string} subtrahend Subtrahend\r\n * @returns {!Long} Difference\r\n */\r\nLongPrototype.subtract = function subtract(subtrahend) {\r\n    if (!isLong(subtrahend))\r\n        subtrahend = fromValue(subtrahend);\r\n    return this.add(subtrahend.neg());\r\n};\r\n\r\n/**\r\n * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\r\n * @function\r\n * @param {!Long|number|string} subtrahend Subtrahend\r\n * @returns {!Long} Difference\r\n */\r\nLongPrototype.sub = LongPrototype.subtract;\r\n\r\n/**\r\n * Returns the product of this and the specified Long.\r\n * @param {!Long|number|string} multiplier Multiplier\r\n * @returns {!Long} Product\r\n */\r\nLongPrototype.multiply = function multiply(multiplier) {\r\n    if (this.isZero())\r\n        return ZERO;\r\n    if (!isLong(multiplier))\r\n        multiplier = fromValue(multiplier);\r\n\r\n    // use wasm support if present\r\n    if (wasm) {\r\n        var low = wasm.mul(this.low,\r\n                           this.high,\r\n                           multiplier.low,\r\n                           multiplier.high);\r\n        return fromBits(low, wasm.get_high(), this.unsigned);\r\n    }\r\n\r\n    if (multiplier.isZero())\r\n        return ZERO;\r\n    if (this.eq(MIN_VALUE))\r\n        return multiplier.isOdd() ? MIN_VALUE : ZERO;\r\n    if (multiplier.eq(MIN_VALUE))\r\n        return this.isOdd() ? MIN_VALUE : ZERO;\r\n\r\n    if (this.isNegative()) {\r\n        if (multiplier.isNegative())\r\n            return this.neg().mul(multiplier.neg());\r\n        else\r\n            return this.neg().mul(multiplier).neg();\r\n    } else if (multiplier.isNegative())\r\n        return this.mul(multiplier.neg()).neg();\r\n\r\n    // If both longs are small, use float multiplication\r\n    if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\r\n        return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\r\n\r\n    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\r\n    // We can skip products that would overflow.\r\n\r\n    var a48 = this.high >>> 16;\r\n    var a32 = this.high & 0xFFFF;\r\n    var a16 = this.low >>> 16;\r\n    var a00 = this.low & 0xFFFF;\r\n\r\n    var b48 = multiplier.high >>> 16;\r\n    var b32 = multiplier.high & 0xFFFF;\r\n    var b16 = multiplier.low >>> 16;\r\n    var b00 = multiplier.low & 0xFFFF;\r\n\r\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n    c00 += a00 * b00;\r\n    c16 += c00 >>> 16;\r\n    c00 &= 0xFFFF;\r\n    c16 += a16 * b00;\r\n    c32 += c16 >>> 16;\r\n    c16 &= 0xFFFF;\r\n    c16 += a00 * b16;\r\n    c32 += c16 >>> 16;\r\n    c16 &= 0xFFFF;\r\n    c32 += a32 * b00;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c32 += a16 * b16;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c32 += a00 * b32;\r\n    c48 += c32 >>> 16;\r\n    c32 &= 0xFFFF;\r\n    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\r\n    c48 &= 0xFFFF;\r\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\r\n * @function\r\n * @param {!Long|number|string} multiplier Multiplier\r\n * @returns {!Long} Product\r\n */\r\nLongPrototype.mul = LongPrototype.multiply;\r\n\r\n/**\r\n * Returns this Long divided by the specified. The result is signed if this Long is signed or\r\n *  unsigned if this Long is unsigned.\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Quotient\r\n */\r\nLongPrototype.divide = function divide(divisor) {\r\n    if (!isLong(divisor))\r\n        divisor = fromValue(divisor);\r\n    if (divisor.isZero())\r\n        throw Error('division by zero');\r\n\r\n    // use wasm support if present\r\n    if (wasm) {\r\n        // guard against signed division overflow: the largest\r\n        // negative number / -1 would be 1 larger than the largest\r\n        // positive number, due to two's complement.\r\n        if (!this.unsigned &&\r\n            this.high === -0x80000000 &&\r\n            divisor.low === -1 && divisor.high === -1) {\r\n            // be consistent with non-wasm code path\r\n            return this;\r\n        }\r\n        var low = (this.unsigned ? wasm.div_u : wasm.div_s)(\r\n            this.low,\r\n            this.high,\r\n            divisor.low,\r\n            divisor.high\r\n        );\r\n        return fromBits(low, wasm.get_high(), this.unsigned);\r\n    }\r\n\r\n    if (this.isZero())\r\n        return this.unsigned ? UZERO : ZERO;\r\n    var approx, rem, res;\r\n    if (!this.unsigned) {\r\n        // This section is only relevant for signed longs and is derived from the\r\n        // closure library as a whole.\r\n        if (this.eq(MIN_VALUE)) {\r\n            if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\r\n                return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE\r\n            else if (divisor.eq(MIN_VALUE))\r\n                return ONE;\r\n            else {\r\n                // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\r\n                var halfThis = this.shr(1);\r\n                approx = halfThis.div(divisor).shl(1);\r\n                if (approx.eq(ZERO)) {\r\n                    return divisor.isNegative() ? ONE : NEG_ONE;\r\n                } else {\r\n                    rem = this.sub(divisor.mul(approx));\r\n                    res = approx.add(rem.div(divisor));\r\n                    return res;\r\n                }\r\n            }\r\n        } else if (divisor.eq(MIN_VALUE))\r\n            return this.unsigned ? UZERO : ZERO;\r\n        if (this.isNegative()) {\r\n            if (divisor.isNegative())\r\n                return this.neg().div(divisor.neg());\r\n            return this.neg().div(divisor).neg();\r\n        } else if (divisor.isNegative())\r\n            return this.div(divisor.neg()).neg();\r\n        res = ZERO;\r\n    } else {\r\n        // The algorithm below has not been made for unsigned longs. It's therefore\r\n        // required to take special care of the MSB prior to running it.\r\n        if (!divisor.unsigned)\r\n            divisor = divisor.toUnsigned();\r\n        if (divisor.gt(this))\r\n            return UZERO;\r\n        if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\r\n            return UONE;\r\n        res = UZERO;\r\n    }\r\n\r\n    // Repeat the following until the remainder is less than other:  find a\r\n    // floating-point that approximates remainder / other *from below*, add this\r\n    // into the result, and subtract it from the remainder.  It is critical that\r\n    // the approximate value is less than or equal to the real value so that the\r\n    // remainder never becomes negative.\r\n    rem = this;\r\n    while (rem.gte(divisor)) {\r\n        // Approximate the result of division. This may be a little greater or\r\n        // smaller than the actual value.\r\n        approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\r\n\r\n        // We will tweak the approximate result by changing it in the 48-th digit or\r\n        // the smallest non-fractional digit, whichever is larger.\r\n        var log2 = Math.ceil(Math.log(approx) / Math.LN2),\r\n            delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),\r\n\r\n        // Decrease the approximation until it is smaller than the remainder.  Note\r\n        // that if it is too large, the product overflows and is negative.\r\n            approxRes = fromNumber(approx),\r\n            approxRem = approxRes.mul(divisor);\r\n        while (approxRem.isNegative() || approxRem.gt(rem)) {\r\n            approx -= delta;\r\n            approxRes = fromNumber(approx, this.unsigned);\r\n            approxRem = approxRes.mul(divisor);\r\n        }\r\n\r\n        // We know the answer can't be zero... and actually, zero would cause\r\n        // infinite recursion since we would make no progress.\r\n        if (approxRes.isZero())\r\n            approxRes = ONE;\r\n\r\n        res = res.add(approxRes);\r\n        rem = rem.sub(approxRem);\r\n    }\r\n    return res;\r\n};\r\n\r\n/**\r\n * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\r\n * @function\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Quotient\r\n */\r\nLongPrototype.div = LongPrototype.divide;\r\n\r\n/**\r\n * Returns this Long modulo the specified.\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Remainder\r\n */\r\nLongPrototype.modulo = function modulo(divisor) {\r\n    if (!isLong(divisor))\r\n        divisor = fromValue(divisor);\r\n\r\n    // use wasm support if present\r\n    if (wasm) {\r\n        var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(\r\n            this.low,\r\n            this.high,\r\n            divisor.low,\r\n            divisor.high\r\n        );\r\n        return fromBits(low, wasm.get_high(), this.unsigned);\r\n    }\r\n\r\n    return this.sub(this.div(divisor).mul(divisor));\r\n};\r\n\r\n/**\r\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n * @function\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Remainder\r\n */\r\nLongPrototype.mod = LongPrototype.modulo;\r\n\r\n/**\r\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n * @function\r\n * @param {!Long|number|string} divisor Divisor\r\n * @returns {!Long} Remainder\r\n */\r\nLongPrototype.rem = LongPrototype.modulo;\r\n\r\n/**\r\n * Returns the bitwise NOT of this Long.\r\n * @returns {!Long}\r\n */\r\nLongPrototype.not = function not() {\r\n    return fromBits(~this.low, ~this.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the bitwise AND of this Long and the specified.\r\n * @param {!Long|number|string} other Other Long\r\n * @returns {!Long}\r\n */\r\nLongPrototype.and = function and(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the bitwise OR of this Long and the specified.\r\n * @param {!Long|number|string} other Other Long\r\n * @returns {!Long}\r\n */\r\nLongPrototype.or = function or(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns the bitwise XOR of this Long and the given one.\r\n * @param {!Long|number|string} other Other Long\r\n * @returns {!Long}\r\n */\r\nLongPrototype.xor = function xor(other) {\r\n    if (!isLong(other))\r\n        other = fromValue(other);\r\n    return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns this Long with bits shifted to the left by the given amount.\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shiftLeft = function shiftLeft(numBits) {\r\n    if (isLong(numBits))\r\n        numBits = numBits.toInt();\r\n    if ((numBits &= 63) === 0)\r\n        return this;\r\n    else if (numBits < 32)\r\n        return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);\r\n    else\r\n        return fromBits(0, this.low << (numBits - 32), this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shl = LongPrototype.shiftLeft;\r\n\r\n/**\r\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shiftRight = function shiftRight(numBits) {\r\n    if (isLong(numBits))\r\n        numBits = numBits.toInt();\r\n    if ((numBits &= 63) === 0)\r\n        return this;\r\n    else if (numBits < 32)\r\n        return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);\r\n    else\r\n        return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\r\n};\r\n\r\n/**\r\n * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shr = LongPrototype.shiftRight;\r\n\r\n/**\r\n * Returns this Long with bits logically shifted to the right by the given amount.\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\r\n    if (isLong(numBits))\r\n        numBits = numBits.toInt();\r\n    numBits &= 63;\r\n    if (numBits === 0)\r\n        return this;\r\n    else {\r\n        var high = this.high;\r\n        if (numBits < 32) {\r\n            var low = this.low;\r\n            return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);\r\n        } else if (numBits === 32)\r\n            return fromBits(high, 0, this.unsigned);\r\n        else\r\n            return fromBits(high >>> (numBits - 32), 0, this.unsigned);\r\n    }\r\n};\r\n\r\n/**\r\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shru = LongPrototype.shiftRightUnsigned;\r\n\r\n/**\r\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n * @function\r\n * @param {number|!Long} numBits Number of bits\r\n * @returns {!Long} Shifted Long\r\n */\r\nLongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\r\n\r\n/**\r\n * Converts this Long to signed.\r\n * @returns {!Long} Signed long\r\n */\r\nLongPrototype.toSigned = function toSigned() {\r\n    if (!this.unsigned)\r\n        return this;\r\n    return fromBits(this.low, this.high, false);\r\n};\r\n\r\n/**\r\n * Converts this Long to unsigned.\r\n * @returns {!Long} Unsigned long\r\n */\r\nLongPrototype.toUnsigned = function toUnsigned() {\r\n    if (this.unsigned)\r\n        return this;\r\n    return fromBits(this.low, this.high, true);\r\n};\r\n\r\n/**\r\n * Converts this Long to its byte representation.\r\n * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n * @returns {!Array.<number>} Byte representation\r\n */\r\nLongPrototype.toBytes = function toBytes(le) {\r\n    return le ? this.toBytesLE() : this.toBytesBE();\r\n};\r\n\r\n/**\r\n * Converts this Long to its little endian byte representation.\r\n * @returns {!Array.<number>} Little endian byte representation\r\n */\r\nLongPrototype.toBytesLE = function toBytesLE() {\r\n    var hi = this.high,\r\n        lo = this.low;\r\n    return [\r\n        lo        & 0xff,\r\n        lo >>>  8 & 0xff,\r\n        lo >>> 16 & 0xff,\r\n        lo >>> 24       ,\r\n        hi        & 0xff,\r\n        hi >>>  8 & 0xff,\r\n        hi >>> 16 & 0xff,\r\n        hi >>> 24\r\n    ];\r\n};\r\n\r\n/**\r\n * Converts this Long to its big endian byte representation.\r\n * @returns {!Array.<number>} Big endian byte representation\r\n */\r\nLongPrototype.toBytesBE = function toBytesBE() {\r\n    var hi = this.high,\r\n        lo = this.low;\r\n    return [\r\n        hi >>> 24       ,\r\n        hi >>> 16 & 0xff,\r\n        hi >>>  8 & 0xff,\r\n        hi        & 0xff,\r\n        lo >>> 24       ,\r\n        lo >>> 16 & 0xff,\r\n        lo >>>  8 & 0xff,\r\n        lo        & 0xff\r\n    ];\r\n};\r\n\r\n/**\r\n * Creates a Long from its byte representation.\r\n * @param {!Array.<number>} bytes Byte representation\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n * @returns {Long} The corresponding Long value\r\n */\r\nLong.fromBytes = function fromBytes(bytes, unsigned, le) {\r\n    return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);\r\n};\r\n\r\n/**\r\n * Creates a Long from its little endian byte representation.\r\n * @param {!Array.<number>} bytes Little endian byte representation\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {Long} The corresponding Long value\r\n */\r\nLong.fromBytesLE = function fromBytesLE(bytes, unsigned) {\r\n    return new Long(\r\n        bytes[0]       |\r\n        bytes[1] <<  8 |\r\n        bytes[2] << 16 |\r\n        bytes[3] << 24,\r\n        bytes[4]       |\r\n        bytes[5] <<  8 |\r\n        bytes[6] << 16 |\r\n        bytes[7] << 24,\r\n        unsigned\r\n    );\r\n};\r\n\r\n/**\r\n * Creates a Long from its big endian byte representation.\r\n * @param {!Array.<number>} bytes Big endian byte representation\r\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\r\n * @returns {Long} The corresponding Long value\r\n */\r\nLong.fromBytesBE = function fromBytesBE(bytes, unsigned) {\r\n    return new Long(\r\n        bytes[4] << 24 |\r\n        bytes[5] << 16 |\r\n        bytes[6] <<  8 |\r\n        bytes[7],\r\n        bytes[0] << 24 |\r\n        bytes[1] << 16 |\r\n        bytes[2] <<  8 |\r\n        bytes[3],\r\n        unsigned\r\n    );\r\n};\r\n\n\n/***/ })\n/******/ ]);","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport BSON from './../../../../third_party/bson.common.js';\n\nconst bson = BSON.bson;\n\nclass Bson {\n    /**\n     * Serialize a Javascript object.\n     *\n     * @param object The Javascript object to serialize.\n     * @return The Buffer object containing the serialized object.\n     */\n    static serialize (object) {\n        return bson.serialize(object);\n    }\n\n    /**\n     * Deserialize data as BSON.\n     *\n     * @param buffer The buffer containing the serialized set of BSON documents.\n     * @returns The deserialized Javascript Object.\n     */\n    static deserialize (object) {\n        return bson.deserialize(object);\n    }\n}\n\nexport { Bson };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FrameType } from './enums/FrameType.js';\nimport  { Bson } from './../util/Bson.js';\n\n/**\n * @typedef {Object} SdlPacket\n * @property {number} _EXTRA_PARCEL_DATA_LENGTH\n * @property @private {number} _HEADER_SIZE\n * @property @private {number} _HEADER_SIZE_V1\n * @property @private {number} _ENCRYPTION_MASK\n * @property {number} SERVICE_TYPE_CONTROL\n * @property {number} SERVICE_TYPE_RPC\n * @property {number} SERVICE_TYPE_PCM\n * @property {number} SERVICE_TYPE_VIDEO\n * @property {number} SERVICE_TYPE_BULK_DATA\n * @property {number} FRAME_INFO_HEART_BEAT\n * @property {number} FRAME_INFO_START_SERVICE\n * @property {number} FRAME_INFO_START_SERVICE_ACK\n * @property {number} FRAME_INFO_START_SERVICE_NAK\n * @property {number} FRAME_INFO_END_SERVICE\n * @property {number} FRAME_INFO_END_SERVICE_ACK\n * @property {number} FRAME_INFO_END_SERVICE_NAK\n * @property {number} FRAME_INFO_REGISTER_SECONDARY_TRANSPORT\n * @property {number} FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_ACK\n * @property {number} FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_NAK\n * @property {number} FRAME_INFO_TRANSPORT_EVENT_UPDATE\n * @property {number} FRAME_INFO_SERVICE_DATA_ACK\n * @property {number} FRAME_INFO_HEART_BEAT_ACK\n * @property {number} FRAME_INFO_FINAL_CONNESCUTIVE_FRAME\n * @property {number} FRAME_INFO_RESERVED\n\n * @property {function} getVersion\n * @property {function} getEncryption\n * @property {function} getServiceType\n * @property {function} getFrameInfo\n * @property {function} getSessionID\n * @property {function} getMessageID\n * @property {function} getDataSize\n * @property {function} setPayload\n * @property {function} getPayload\n * @property {function} getEncryptionBit\n * @property {function} getFrameType\n * @property {function} toUint8Array\n * @property {function} toString\n * @property @private {function} _constructPacket\n * @property {function} putTag\n * @property {function} getTag\n */\n\nclass SdlPacket {\n    /**\n    * @constructor\n    * @param {Number} version - Protocol version to use\n    * @param {Boolean} encryption - Whether or not the payload in this packet is encrypted\n    * @param {FrameType} frameType - A number representing the packet frame type\n    * @param {ServiceType} serviceType - The service that this packet is associated with\n    * @param {Number} frameInfo - Specific frame info related to this packet\n    * @param {Number} sessionID - ID this packet is associated with\n    * @param {Number} dataSize - Size of the payload that will be added\n    * @param {Number} messageID - ID of this specific packet\n    * @param {Uint8Array} payload - Raw data that will be attached to the packet (RPC message, raw bytes, etc)\n    * @param {Number} offset\n    * @param {Number} bytesToWrite\n    */\n    constructor (version = 1, encryption = false, frameType = -1, serviceType = -1, frameInfo = -1, sessionID = 0, dataSize = 0, messageID = 0, payload = null, offset = 0, bytesToWrite = 0) {\n        this._version = version;\n        this._encryption = encryption;\n        this._frameType = frameType;\n        this._serviceType = serviceType;\n        this._frameInfo = frameInfo;\n        this._sessionID = sessionID;\n        this._dataSize = dataSize;\n        this._messageID = messageID;\n        this._payload = payload;\n        this._offset = offset;\n        this._bytesToWrite = bytesToWrite;\n\n        this._bsonPayload = undefined;\n\n        if (payload !== null) {\n            this._payload = new Uint8Array(payload.slice(offset, bytesToWrite + offset));\n        }\n\n        return this;\n    }\n\n    /**\n    * @return {Number} - Protocol version used by this packet\n    */\n    getVersion () {\n        return this._version;\n    }\n\n    /**\n    * @return {Boolean} - Whether or not the payload in this packet is encrypted\n    */\n    getEncryption () {\n        return this._encryption;\n    }\n\n    /**\n    * @return {ServiceType} - The service that this packet is associated with\n    */\n    getServiceType () {\n        return this._serviceType;\n    }\n\n    /**\n    * @return {Number} - Specific frame info related to this packet\n    */\n    getFrameInfo () {\n        return this._frameInfo;\n    }\n\n    /**\n    * @return {Number} - ID this packet is associated with\n    */\n    getSessionID () {\n        return this._sessionID;\n    }\n\n    /**\n    * @return {Number} - ID of this specific packet\n    */\n    getMessageID () {\n        return this._messageID;\n    }\n\n    /**\n    * @return {Number} - Size of the payload that will be added\n    */\n    getDataSize () {\n        return this._dataSize;\n    }\n\n    /**\n    * @param {Uint8Array} payload\n    * @return {SdlPacket}\n    */\n    setPayload (payload) {\n        this._payload = payload;\n        return this;\n    }\n\n    /**\n    * @return {Uint8Array} - Raw data that will be attached to the packet (RPC message, raw bytes, etc)\n    */\n    getPayload () {\n        return this._payload;\n    }\n\n\n    /**\n     *\n     * @param {Boolean} encryption\n     * @return {Number} - Returns a number representing a byte mask depending on the boolean value\n     */\n    static getEncryptionBit (encryption) {\n        return encryption ? SdlPacket._ENCRYPTION_MASK : 0;\n    }\n\n    /**\n    * @return {FrameType} - A number representing the packet frame type\n    */\n    getFrameType () {\n        if (FrameType.keyForValue(this._frameType) !== null) {\n            return this._frameType;\n        } else {\n            return FrameType.SINGLE;\n        }\n    }\n\n    /**\n    * @return {String} - String representation of the packet\n    */\n    toString () {\n        let output = '***** Sdl Packet *****';\n        output += `\\nVersion: ${this._version}`;\n        output += `\\nEncryption: ${this._encryption}`;\n        output += `\\nFrameType: ${this._frameType}`;\n        output += `\\nServiceType: ${this._serviceType}`;\n        output += `\\nFrameInfo: ${this._frameInfo}`;\n        output += `\\nSessionID: ${this._sessionID}`;\n        output += `\\nDataSize: ${this._dataSize}`;\n\n        if (this._version > 1) {\n            output += `\\nMessageID: ${this._messageID}`;\n        }\n\n        output += '\\n***** Sdl Packet End *****';\n\n        return output;\n    }\n\n    /**\n\t * This method takes in the various components to the SDL packet structure and creates a new byte array that can be sent via the transport\n     * @param {Number} version - Protocol version to use\n     * @param {Boolean} encryption - Whether or not the payload in this packet is encrypted\n     * @param {FrameType} frameType - A number representing the packet frame type\n     * @param {ServiceType} serviceType - The service that this packet is associated with\n     * @param {Number} controlFrameInfo - Specific frame info related to this packet\n     * @param {Number} sessionID - ID this packet is associated with\n     * @param {Number} dataSize - Size of the payload that will be added\n     * @param {Number} messageID - ID of this specific packet\n     * @param {Uint8Array} payload - Raw data that will be attached to the packet (RPC message, raw bytes, etc)\n\t * @return {Uint8Array} - A byte[] representation of an SdlPacket built using the supplied params\n\t */\n    static _constructPacket (version, encryption, frameType, serviceType, controlFrameInfo, sessionID, dataSize, messageID, payload) {\n        let dataView = null;\n        let dataViewIndex = 0;\n\n        if (version > 1) {\n            dataView = new Uint8Array(SdlPacket._HEADER_SIZE + dataSize);\n        } else {\n            dataView = new Uint8Array(SdlPacket._HEADER_SIZE_V1 + dataSize);\n        }\n\n        dataView[dataViewIndex++] = (version << 4) + SdlPacket.getEncryptionBit(encryption) + frameType;\n        dataView[dataViewIndex++] = serviceType;\n        dataView[dataViewIndex++] = controlFrameInfo;\n        dataView[dataViewIndex++] = sessionID;\n        dataView[dataViewIndex++] = (dataSize & 0xFF000000) >> 24;\n        dataView[dataViewIndex++] = (dataSize & 0x00FF0000) >> 16;\n        dataView[dataViewIndex++] = (dataSize & 0x0000FF00) >> 8;\n        dataView[dataViewIndex++] = dataSize & 0x000000FF;\n\n        if (version > 1) {\n            dataView[dataViewIndex++] = (messageID & 0xFF000000) >> 24;\n            dataView[dataViewIndex++] = (messageID & 0x00FF0000) >> 16;\n            dataView[dataViewIndex++] = (messageID & 0x0000FF00) >> 8;\n            dataView[dataViewIndex++] = messageID & 0x000000FF;\n        }\n\n        if (payload !== null && payload.length > 0) {\n            dataView.set(payload, dataViewIndex);\n        }\n\n        return dataView;\n    }\n\n    /**\n\t * This method converts an SdlPacket instance to a new byte array that can be sent via the transport\n\t * @return {Uint8Array} - A byte[] representation of an SdlPacket built using the supplied params\n\t */\n    toPacket () {\n        if (this._bsonPayload) {\n            this._payload = Bson.serialize(this._bsonPayload);\n            this._dataSize = this._payload.length;\n        }\n\n        return SdlPacket._constructPacket(this._version, this._encryption, this._frameType, this._serviceType, this._frameInfo, this._sessionID, this._dataSize, this._messageID, this._payload);\n    }\n\n    /**\n     * @param {String} tag - String key to add as a property to the BSON map\n     * @param {Object} data - Object to add as a value to the BSON map\n     */\n    putTag (tag, data) {\n        if (!this._bsonPayload) {\n            this._bsonPayload = {};\n        }\n        this._bsonPayload[tag] = data;\n    }\n\n    /**\n     * @param {String} tag - String key to add as a property to the BSON map\n     * @return {Object} data - Object as a value found from the the BSON map\n     */\n\n    getTag (tag) {\n        if (!this._bsonPayload) {\n            if (!this._payload || this._payload.length === 0) {\n                return null;\n            }\n            this._bsonPayload = Bson.deserialize(this._payload);\n            return this._bsonPayload[tag];\n        } else {\n            return this._bsonPayload[tag];\n        }\n    }\n}\n\nSdlPacket._EXTRA_PARCEL_DATA_LENGTH                      = 24;\nSdlPacket._HEADER_SIZE                                   = 12;\nSdlPacket._HEADER_SIZE_V1                                = 8;\n\nSdlPacket._ENCRYPTION_MASK                               = 0x08;\n\n/**\n * Service Type\n */\nSdlPacket.SERVICE_TYPE_CONTROL                          = 0x00;\n// RESERVED 0x01 - 0x06\nSdlPacket.SERVICE_TYPE_RPC                              = 0x07;\n// RESERVED 0x08 - 0x09\nSdlPacket.SERVICE_TYPE_PCM                              = 0x0A;\nSdlPacket.SERVICE_TYPE_VIDEO                            = 0x0B;\n// RESERVED 0x0C - 0x0E\nSdlPacket.SERVICE_TYPE_BULK_DATA                        = 0x0F;\n// RESERVED 0x10 - 0xFF\n\n/**\n * Frame Info\n */\nSdlPacket.FRAME_INFO_HEART_BEAT                         = 0x00;\nSdlPacket.FRAME_INFO_START_SERVICE                      = 0x01;\nSdlPacket.FRAME_INFO_START_SERVICE_ACK                  = 0x02;\nSdlPacket.FRAME_INFO_START_SERVICE_NAK                  = 0x03;\nSdlPacket.FRAME_INFO_END_SERVICE                        = 0x04;\nSdlPacket.FRAME_INFO_END_SERVICE_ACK                    = 0x05;\nSdlPacket.FRAME_INFO_END_SERVICE_NAK                    = 0x06;\nSdlPacket.FRAME_INFO_REGISTER_SECONDARY_TRANSPORT       = 0x07;\nSdlPacket.FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_ACK   = 0x08;\nSdlPacket.FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_NAK   = 0x09;\n// 0x0A-0xFC are reserved\nSdlPacket.FRAME_INFO_TRANSPORT_EVENT_UPDATE             = 0xFD;\nSdlPacket.FRAME_INFO_SERVICE_DATA_ACK                   = 0xFE;\nSdlPacket.FRAME_INFO_HEART_BEAT_ACK                     = 0xFF;\nSdlPacket.FRAME_INFO_FINAL_CONNESCUTIVE_FRAME           = 0x00;\nSdlPacket.FRAME_INFO_RESERVED                           = 0x00;\n\nexport { SdlPacket };\n","export default (typeof global !== \"undefined\" ? global :\n            typeof self !== \"undefined\" ? self :\n            typeof window !== \"undefined\" ? window : {});\n","\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\nvar inited = false;\nfunction init () {\n  inited = true;\n  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\n  for (var i = 0, len = code.length; i < len; ++i) {\n    lookup[i] = code[i]\n    revLookup[code.charCodeAt(i)] = i\n  }\n\n  revLookup['-'.charCodeAt(0)] = 62\n  revLookup['_'.charCodeAt(0)] = 63\n}\n\nexport function toByteArray (b64) {\n  if (!inited) {\n    init();\n  }\n  var i, j, l, tmp, placeHolders, arr\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n\n  // base64 is 4/3 + up to two characters of the original data\n  arr = new Arr(len * 3 / 4 - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nexport function fromByteArray (uint8) {\n  if (!inited) {\n    init();\n  }\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var output = ''\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n","\nexport function read (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexport function write (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nexport default Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n\nimport * as base64 from './base64'\nimport * as ieee754 from './ieee754'\nimport isArray from './isArray'\n\nexport var INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : true\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nvar _kMaxLength = kMaxLength()\nexport {_kMaxLength as kMaxLength};\nfunction typedArraySupport () {\n  return true;\n  // rollup issues\n  // try {\n  //   var arr = new Uint8Array(1)\n  //   arr.__proto__ = {\n  //     __proto__: Uint8Array.prototype,\n  //     foo: function () { return 42 }\n  //   }\n  //   return arr.foo() === 42 && // typed array instances can be augmented\n  //       typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n  //       arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  // } catch (e) {\n  //   return false\n  // }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nexport function Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    // Object.defineProperty(Buffer, Symbol.species, {\n    //   value: null,\n    //   configurable: true\n    // })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (internalIsBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nexport function SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\nBuffer.isBuffer = isBuffer;\nfunction internalIsBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!internalIsBuffer(a) || !internalIsBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!internalIsBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (internalIsBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!internalIsBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (internalIsBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!internalIsBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = internalIsBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n\n\n// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nexport function isBuffer(obj) {\n  return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))\n}\n\nfunction isFastBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))\n}\n","class TextEncoder {\n    // https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder#Polyfill\n    static encode (str) {\n        const Len = str.length;\n        let resPos = -1;\n        // The Uint8Array's length must be at least 3x the length of the string because an invalid UTF-16\n        //  takes up the equivelent space of 3 UTF-8 characters to encode it properly. However, Array's\n        //  have an auto expanding length and 1.5x should be just the right balance for most uses.\n        const resArr = [];\n        for (let point = 0, nextcode = 0, idx = 0; idx !== Len;) {\n            point = str.charCodeAt(idx), idx += 1;\n            if (point >= 0xD800 && point <= 0xDBFF) {\n                if (idx === Len) {\n                    resArr[resPos += 1] = 0xef;\n                    resArr[resPos += 1] = 0xbf;\n                    resArr[resPos += 1] = 0xbd;\n                    break;\n                }\n                // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n                nextcode = str.charCodeAt(idx);\n                if (nextcode >= 0xDC00 && nextcode <= 0xDFFF) {\n                    point = ((point - 0xD800) * 0x400) + nextcode - 0xDC00 + 0x10000;\n                    idx += 1;\n                    if (point > 0xffff) {\n                        resArr[resPos += 1] = (0x1e << 3) | (point >>> 18);\n                        resArr[resPos += 1] = (0x2 << 6) | ((point >>> 12) & 0x3f);\n                        resArr[resPos += 1] = (0x2 << 6) | ((point >>> 6) & 0x3f);\n                        resArr[resPos += 1] = (0x2 << 6) | (point & 0x3f);\n                        continue;\n                    }\n                } else {\n                    resArr[resPos += 1] = 0xef; resArr[resPos += 1] = 0xbf;\n                    resArr[resPos += 1] = 0xbd; continue;\n                }\n            }\n            if (point <= 0x007f) {\n                resArr[resPos += 1] = (0x0 << 7) | point;\n            } else if (point <= 0x07ff) {\n                resArr[resPos += 1] = (0x6 << 5) | (point >>> 6);\n                resArr[resPos += 1] = (0x2 << 6) | (point & 0x3f);\n            } else {\n                resArr[resPos += 1] = (0xe << 4) | (point >>> 12);\n                resArr[resPos += 1] = (0x2 << 6) | ((point >>> 6) & 0x3f);\n                resArr[resPos += 1] = (0x2 << 6) | (point & 0x3f);\n            }\n        }\n        // else // IE 6-9\n        resArr.length = resPos + 1; // trim off extra weight\n        return resArr;\n    }\n}\n\nexport { TextEncoder };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TextEncoder } from './TextEncoder.js';\nimport { RpcStruct } from '../rpc/RpcStruct.js';\n\nclass JsonRpcMarshaller {\n    /**\n     * Takes an RPC message and converts it\n     * into a byte array that can be added\n     * as part of the SdlPacket.\n     * @param {RpcStruct} rpcStruct - This param contains the json object to transform\n     * based on the getParameters method. This can be an RpcStruct or something like RpcMessage\n     * which extends RpcStruct.\n     * @returns {null|Uint8Array} - Either the byte array or null on error.\n     */\n    static marshall (rpcStruct) {\n        let jsonBytes = null;\n        function paramify (rpcStruct) {\n            const params = rpcStruct.getParameters();\n            for (const key in params) {\n                if (params[key] instanceof RpcStruct) {\n                    params[key] = paramify(params[key]);\n                }\n            }\n            return params;\n        }\n\n        try {\n            const jsonObject = paramify(rpcStruct);\n            const stringVersion = JSON.stringify(jsonObject);\n            jsonBytes = this._encode(stringVersion);\n        } catch (error) {\n            console.error('Failed to encode messages to JSON.', error);\n        }\n        return jsonBytes;\n    }\n\n    /**\n     * Takes a byte array and transforms it into a json object.\n     * @param {Uint8Array} bytes - Byte array containing the json string to convert.\n     * @returns {null|Object} - Either a json object or null on error in parsing.\n     */\n    static unmarshall (bytes) {\n        let ret = null;\n        try {\n            const jsonString = this._decode(bytes);\n            ret = JSON.parse(jsonString);\n        } catch (error) {\n            console.error('Failed to parse JSON', error);\n        }\n        return ret;\n    }\n\n    /**\n     * Transform a string into a byte array.\n     * @param {String} str - String to transform.\n     * @returns {Uint8Array}\n     * @private\n     */\n    static _encode (str) {\n        return new Uint8Array(TextEncoder.encode(str));\n    }\n\n    /**\n     * Transform a byte array into a string.\n     * @param {Uint8Array} bytes - Byte array to transform.\n     * @returns {String}\n     * @private\n     */\n    static _decode (bytes) {\n        return Buffer.from(bytes).toString();\n    }\n}\n\nexport { JsonRpcMarshaller };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * Contains the raw json data and bulk data for an RPC request/response along with the basic header info\n * rpc type, function id, and correlation id.\n *\n * This class can parse incoming data from sdl core and assemble a binary header to send to sdl core.\n *\n *\n *  @private {number} _rpcType - Request = 0, Response = 1, Notification = 2.\n *  @private {number} _functionId - Matches a function Id in the mobile api spec https://github.com/smartdevicelink/rpc_spec/blob/master/MOBILE_API.xml\n *  @private {number} _correlationId - For a request this id is provided and the matching response will have this same id.\n *  @private {number} _jsonSize - Size of json.\n *  @private {Uint8Array} _jsonData - Raw json data. This can be parsed using the JsonRpcMarshaller.\n *  @private {Uint8Array} _bulkData - Bulk data (optional). If something cannot be expressed as a json object it will be in the bulk data (eg PutFile/GetFile has the full file in bulk data.)\n */\nclass BinaryFrameHeader {\n    /**\n     *\n     * @param {number} rpcType\n     * @param {number} functionId\n     * @param {number} correlationId\n     * @param {number} jsonSize\n     * @constructor\n     */\n    constructor (rpcType, functionId, correlationId, jsonSize) {\n        this._rpcType = rpcType;\n        this._functionId = functionId;\n        this._correlationId = correlationId;\n        this._jsonSize = jsonSize;\n        this._bulkData = null;\n        this._jsonData = null;\n    }\n\n    /**\n     * Given a byte array with uint8 values, a BinaryFrameHeader instance is created.\n     * @param {array} binaryFrameHeaderData - Byte array containing basic information on the frames type, length, and related ids.\n     * @returns {BinaryFrameHeader}\n     */\n    static fromBinaryHeader (binaryFrameHeaderData) {\n        const rpcType = binaryFrameHeaderData[0] >> 4;\n\n        let functionId = (binaryFrameHeaderData[0] & 0x0F) << 24;\n        functionId += (binaryFrameHeaderData[1] & 0xFF) << 16;\n        functionId += (binaryFrameHeaderData[2] & 0xFF) << 8;\n        functionId += binaryFrameHeaderData[3] & 0xFF;\n\n        let correlationId = (binaryFrameHeaderData[4] & 0xFF) << 24;\n        correlationId += (binaryFrameHeaderData[5] & 0xFF) << 16;\n        correlationId += (binaryFrameHeaderData[6] & 0xFF) << 8;\n        correlationId += binaryFrameHeaderData[7] & 0xFF;\n\n        let jsonSize = (binaryFrameHeaderData[8] & 0xFF) << 24;\n        jsonSize += (binaryFrameHeaderData[9] & 0xFF) << 16;\n        jsonSize += (binaryFrameHeaderData[10] & 0xFF) << 8;\n        jsonSize += binaryFrameHeaderData[11] & 0xFF;\n\n        const binaryFrameHeader = new BinaryFrameHeader(rpcType, functionId, correlationId, jsonSize);\n\n        const jsonDataStart = BinaryFrameHeader.HEADER_SIZE;\n        const jsonDataEnd = BinaryFrameHeader.HEADER_SIZE + jsonSize;\n\n        binaryFrameHeader.setJsonData(binaryFrameHeaderData.slice(jsonDataStart, jsonDataEnd));\n\n        // any data after the JSON data is the bulk data (eg PutFile contains the file after the main json)\n        if (binaryFrameHeaderData.length > jsonDataEnd) {\n            const bulkData = binaryFrameHeaderData.slice(jsonDataEnd);\n            binaryFrameHeader.setBulkData(bulkData);\n        }\n        return binaryFrameHeader;\n    }\n\n\n    /**\n     * Assembles binary header data.\n     * @returns {array}\n     */\n    assembleHeaderBytes () {\n        const buffer = [];\n        const functionId = this._functionId;\n        const correlationId = this._correlationId;\n        const rpcType = this._rpcType;\n\n        buffer.push((functionId & 0x0F000000) >> 24) + (rpcType << 4);\n        buffer.push((functionId & 0x00FF0000) >> 16);\n        buffer.push((functionId & 0x0000FF00) >> 8);\n        buffer.push(functionId & 0x000000FF);\n\n        buffer.push((correlationId & 0xFF000000) >> 24);\n        buffer.push((correlationId & 0x00FF0000) >> 16);\n        buffer.push((correlationId & 0x0000FF00) >> 8);\n        buffer.push(correlationId & 0x000000FF);\n\n        const jsonSize = this._jsonSize;\n        buffer.push((jsonSize & 0xFF000000) >> 24);\n        buffer.push((jsonSize & 0x00FF0000) >> 16);\n        buffer.push((jsonSize & 0x0000FF00) >> 8);\n        buffer.push(jsonSize & 0x000000FF);\n\n        return buffer;\n    }\n\n    /**\n     * Sets the rpc type of the binary header.\n     * @param {number} type\n     * @returns {BinaryFrameHeader}\n     */\n    setRpcType (type) {\n        this._rpcType = type;\n        return this;\n    }\n\n    /**\n     * Gets the rpc type of the binary header\n     * @returns {number}\n     */\n    getRpcType () {\n        return this._rpcType;\n    }\n\n    /**\n     * Sets the function id of the binary header.\n     * @param {number} id\n     * @returns {BinaryFrameHeader}\n     */\n    setFunctionId (id) {\n        this._functionId = id;\n        return this;\n    }\n\n    /**\n     * Gets the function Id of the binary header.\n     * @returns {number}\n     */\n    getFunctionId () {\n        return this._functionId;\n    }\n\n    /**\n     * Sets the correlation Id of the binary header.\n     * @param {number} id\n     * @returns {BinaryFrameHeader}\n     */\n    setCorrelationId (id) {\n        this._correlationId = id;\n        return this;\n    }\n\n    /**\n     * Gets the correlation Id of the binary header.\n     */\n    getCorrelationId () {\n        return this._correlationId;\n    }\n\n    /**\n     * Sets the json size of the binary header.\n     * @param {number} size\n     * @returns {BinaryFrameHeader}\n     */\n    setJsonSize (size) {\n        this._jsonSize = size;\n        return this;\n    }\n\n    /**\n     * Gest the json size of the binary header.\n     * @returns {number}\n     */\n    getJsonSize () {\n        return this._jsonSize;\n    }\n\n    /**\n     * Returns the json data as a byte array.\n     * @returns {array} - Byte array of json data.\n     */\n    getJsonData () {\n        return this._jsonData;\n    }\n\n    /**\n     * Sets the json data of the binary header.\n     * @param {array} data - Byte array of json data\n     * @returns {BinaryFrameHeader}\n     */\n    setJsonData (data) {\n        this._jsonData = data;\n        return this;\n    }\n\n    /**\n     * Sets the bulk data of the binary header.\n     * Supported by protcol 2 and up.\n     * @param {array} data - Byte array of bulk data\n     */\n    setBulkData (data) {\n        this._bulkData = data;\n        return this;\n    }\n\n    /**\n     * Gets the bulk data of the binary header.\n     * Supported by protcol 2 and up.\n     * @returns {array} - Byte array of bulk data\n     */\n    getBulkData () {\n        return this._bulkData;\n    }\n}\n\nBinaryFrameHeader.HEADER_SIZE = 12;\n\nexport { BinaryFrameHeader };\n\n\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\nimport { FrameType } from './enums/FrameType.js';\nimport { SdlPacket } from './SdlPacket.js';\nimport { FunctionID } from './../rpc/enums/FunctionID.js';\nimport { JsonRpcMarshaller } from './../util/JsonRpcMarshaller.js';\nimport { BinaryFrameHeader } from './BinaryFrameHeader.js';\n\n\n/**\n * Takes an rpc message and converts it into packets ready to send.\n */\nclass MessageFrameDisassembler {\n    /**\n      *\n      * @param {RpcRequest} rpcRequest - RPC message that will split into smaller sdl packets.\n      * @param {Number} sessionId - sessionId for packets\n      * @param {Number} messageId - messageId for packets.\n      * @param {Number} mtu - max transport unit, used to determine packet size to send.\n      * @param {Number} version - major version\n      * @param {Boolean} isEncrypted - packet is encrypted\n      * @param {cb} packetCallback - This function will be called when a packet is ready to send.\n      * @constructor\n      */\n    constructor (rpcRequest, sessionId, messageId, mtu, version, isEncrypted, packetCallback) {\n        this._rpcRequest = rpcRequest;\n        this._sessionId = sessionId;\n        this._messageId = messageId;\n        this._isEncrypted = isEncrypted;\n\n        if (!mtu) {\n            throw new Error('MTU must be specified.');\n        }\n        this._mtu = mtu;\n\n        if (!version) {\n            throw new Error('Version must be specified.');\n        }\n        this._version = version;\n        this._packetCallback = packetCallback;\n    }\n\n    /**\n      * Immediately build rpc and respond to packetcallback with packets to send.\n      * @param {RpcRequest} rpcMessage - RPC message that will split into smaller sdl packets.\n      * @param {Number} sessionId - sessionId for packets\n      * @param {Number} messageId - messageId for packets.\n      * @param {Number} mtu - max transport unit, used to determine packet size to send.\n      * @param {Number} version - major version\n      * @param {Boolean} isEncrypted - packet is encrypted\n      * @param {cb} packetCallback - This function will be called when a packet is ready to send.\n      */\n    static buildRPC (rpcRequest, sessionId, messageId, mtu, version, isEncrypted, cb) {\n        const obj = new MessageFrameDisassembler(rpcRequest, sessionId, messageId, mtu, version, isEncrypted, cb);\n        obj._doRequest();\n        return obj;\n    }\n\n\n    /**\n     * Constructs the main BinaryFrameHeader buffer.\n     * @returns {Unit8Array}\n     */\n    _buildRPCMainBuffer () {\n        const rpcBulkData = this._rpcRequest.getBulkData();\n        const correlationId = this._rpcRequest.getCorrelationId();\n        const rpcType =  this._rpcRequest.getRPCType();\n\n        const functionName = this._rpcRequest.getFunctionName();\n        const functionId = FunctionID.valueForKey(functionName);\n        if (!functionId) {\n            throw new Error(`Failed to find function ${functionName}`);\n        }\n\n        const jsonBuffer = JsonRpcMarshaller.marshall(this._rpcRequest);\n        const jsonSize = jsonBuffer.length;\n\n        const bfh = new BinaryFrameHeader(rpcType, functionId, correlationId);\n        bfh.setJsonData(jsonBuffer);\n        bfh.setJsonSize(jsonSize);\n        bfh.setBulkData(rpcBulkData);\n        const headerSize = 12;\n        const bulkData = bfh.getBulkData();\n        let bulkDataSize = 0;\n        if (bulkData) {\n            bulkDataSize = bulkData.length;\n        }\n        const totalMessageSize = headerSize + jsonSize + bulkDataSize;\n        const data = new Uint8Array(totalMessageSize);\n        data.set(bfh.assembleHeaderBytes(), 0);\n        data.set(jsonBuffer, headerSize);\n        if (bulkData) {\n            data.set(bulkData, headerSize + jsonSize);\n        }\n        return data;\n    }\n\n\n    /**\n     * Start the RPC request and use callback to send\n     * sdl packets of the appropriate size.\n     * @private\n     */\n    _doRequest () {\n        const version = this._version;\n        const frameInfo = 0;\n        const frameType = FrameType.SINGLE;\n\n        const serviceType = SdlPacket.SERVICE_TYPE_RPC;\n        const sessionId = this._sessionId;\n        const messageId = this._messageId;\n\n        const isEncrypted = this._isEncrypted;\n        const mainBuffer = this._buildRPCMainBuffer();\n        const mtu = this._mtu;\n\n        const frameCount = Math.ceil(mainBuffer.length / mtu);\n\n        if (frameCount <= 1) {\n            const fullPacket = this._constructPacket(\n                version,\n                serviceType,\n                frameInfo,\n                sessionId,\n                messageId,\n                frameType,\n                mainBuffer,\n                isEncrypted\n            );\n            this._packetCallback(fullPacket);\n        } else {\n            const buffer = new ArrayBuffer(8); // Int32 has 8 bytes\n            const view = new DataView(buffer);\n            view.setUint32(0, mainBuffer.length, false);\n            view.setUint32(4, frameCount, false);\n            const payload = new Uint8Array(buffer);\n\n            const firstHeader = this._constructPacket(version, serviceType, frameInfo, sessionId, messageId, FrameType.FIRST, payload, isEncrypted);\n            this._packetCallback(firstHeader);\n\n            this._buildConsecutiveFrames(\n                version,\n                serviceType,\n                sessionId,\n                messageId,\n                mainBuffer,\n                mtu,\n                isEncrypted\n            );\n        }\n    }\n\n\n    /**\n     * Creates an sdl packet.\n     * @param {Number} version\n     * @param {ServiceType} serviceType\n     * @param {Number} frameInfo\n     * @param {Number} sessionId\n     * @param {Number} messageId\n     * @param {Number} frameType\n     * @param {Unit8Array} payload\n     * @param {Boolean} isEncrypted\n     * @returns {SdlPacket}\n     */\n    _constructPacket (version, serviceType, frameInfo, sessionId, messageId, frameType, payload, isEncrypted) {\n        const dataSize = payload.length;\n        const offset = 0;\n        const bytesToWrite = dataSize;\n        const sdlPacket = new SdlPacket(version, isEncrypted, frameType, serviceType, frameInfo, sessionId, dataSize, messageId, payload, offset, bytesToWrite);\n        return sdlPacket;\n    }\n\n\n    /**\n     * Builds consecutive frames after the inital frame is sent for a multi-frame message.\n     * @param {Number} version\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId\n     * @param {Number} messageId\n     * @param {Buffer} buffer\n     * @param {Number} length\n     * @param {Boolean} isEncrypted\n     */\n    _buildConsecutiveFrames (version, serviceType, sessionId, messageId, buffer, length, isEncrypted) {\n        let frameSequenceNumber;\n        let count = 0;\n        let offset = 0;\n\n        while (frameSequenceNumber !== 0) {\n            if (offset + length >= buffer.length) {\n                frameSequenceNumber = 0; // last frame\n            } else {\n                frameSequenceNumber = (count % 255) + 1; // 1,2,3,...,255,1\n            }\n\n            const header = this._constructPacket(\n                version,\n                serviceType,\n                frameSequenceNumber,\n                sessionId,\n                messageId,\n                FrameType.CONSECUTIVE,\n                buffer.slice(offset, offset + length),\n                isEncrypted\n            );\n            this._packetCallback(header);\n            count++;\n            offset += length;\n        }\n    }\n}\n\n\n\nexport { MessageFrameDisassembler };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass TransportListener {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this._onTransportConnected = null;\n        this._onTransportDisconnected = null;\n        this._onError = null;\n        this._onPacketReceived = null;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnTransportConnected (func) {\n        this._onTransportConnected = func;\n\n        return this;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnTransportDisconnected (func) {\n        this._onTransportDisconnected = func;\n\n        return this;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnError (func) {\n        this._onError = func;\n\n        return this;\n    }\n\n    /**\n     * @param {Function} func\n     * @return {TransportListener}\n     */\n    setOnPacketReceived (func) {\n        this._onPacketReceived = func;\n\n        return this;\n    }\n\n\n    onTransportConnected () {\n        if (typeof this._onTransportConnected === 'function') {\n            this._onTransportConnected();\n        }\n    }\n\n    onTransportDisconnected () {\n        if (typeof this._onTransportDisconnected === 'function') {\n            this._onTransportDisconnected();\n        }\n    }\n\n    onError (error = null) {\n        if (typeof this._onError === 'function') {\n            this._onError(error);\n        }\n    }\n\n    onPacketReceived (sdlPacket) {\n        if (typeof this._onPacketReceived === 'function') {\n            this._onPacketReceived(sdlPacket);\n        }\n    }\n}\n\nexport { TransportListener };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass Version {\n    /**\n    * @constructor\n    */\n    constructor (major, minor, patch) {\n        this.setMajor(major);\n        this.setMinor(minor);\n        this.setPatch(patch);\n    }\n\n    /**\n    * @param {Number} major\n    * @return {Version}\n    */\n    setMajor (major) {\n        this._major = parseInt(major) || 0;\n\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getMajor () {\n        return this._major;\n    }\n\n    /**\n    * @param {Number} minor\n    * @return {Version}\n    */\n    setMinor (minor) {\n        this._minor = parseInt(minor) || 0;\n\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getMinor () {\n        return this._minor;\n    }\n\n    /**\n    * @param {Number} patch\n    * @return {Version}\n    */\n    setPatch (patch) {\n        this._patch = parseInt(patch) || 0;\n\n        return this;\n    }\n\n    /**\n    * @return {Number}\n    */\n    getPatch () {\n        return this._patch;\n    }\n\n    /**\n    * @param {String} version - Parse this string to a Version object\n    * @return {Version}\n    */\n    fromString (version) {\n        const versions = version.split('.');\n        if (versions.length !== 3) {\n            throw new Error('Incorrect version string format');\n        }\n        this.setMajor(versions[0]);\n        this.setMinor(versions[1]);\n        this.setPatch(versions[2]);\n\n        return this;\n    }\n\n    /**\n    * @return {String}\n    */\n    toString () {\n        return `${this.getMajor()}.${this.getMinor()}.${this.getPatch()}`;\n    }\n\n    /**\n    * Method to test if this instance of Version is newer than the supplied one.\n    * @param version - the version to check against\n    * @return {Number} - 1 if this instance is newer, -1 if supplied version is newer, and 0 if they are equal\n    */\n    isNewerThan (version) {\n        if (this.getMajor() > version.getMajor()) {\n            return 1;\n        } else if (this.getMajor() === version.getMajor()) {\n            if (this.getMinor() > version.getMinor()) {\n                return 1;\n            } else if (this.getMinor() === version.getMinor()) {\n                if (this.getPatch() > version.getPatch()) {\n                    return 1;\n                } else if (this.getPatch() === version.getPatch()) {\n                    return 0;\n                }\n            }\n        }\n        return -1;\n    }\n}\n\nexport { Version };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ServiceType\n * @property {Object} _MAP\n */\nclass ServiceType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get CONTROL () {\n        return ServiceType._MAP.CONTROL;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get RPC () {\n        return ServiceType._MAP.RPC;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get AUDIO () {\n        return ServiceType._MAP.AUDIO;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get VIDEO () {\n        return ServiceType._MAP.VIDEO;\n    }\n\n    /**\n    * @return {Number}\n    */\n    static get HYBRID () {\n        return ServiceType._MAP.HYBRID;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return ServiceType._valueForKey(key, ServiceType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return ServiceType._keyForValue(value, ServiceType._MAP);\n    }\n}\n\nServiceType._MAP = Object.freeze({\n    'CONTROL': 0x00,\n    'RPC': 0x07,\n    'AUDIO': 0x0A,\n    'VIDEO': 0x0B,\n    'HYBRID':0x0F,\n});\n\nexport { ServiceType };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FrameType } from './enums/FrameType.js';\nimport { SdlPacket } from './SdlPacket.js';\n\n/**\n * Callback for finished packet.\n * @callback cb\n * @param {string} error - If there is an error that cannot be recovered from it will be returned.\n * @param {SdlPacket} sdlPacket - Finished sdl packet.\n */\n\n/**\n * Assembles sdl packets which may come in seperate chunks if the data exceeds the\n * max transport unit allowed by sdl core.\n *\n * @private {cb} _callback - Callback for combined packet.\n * @private {number} _totalConsecutiveFrames - Total consecutive frames expected for a multiframe packet.\n * @private {number} _consecutiveFramesDataLength - Expected data length of finished multiframe packet.\n * @private {number} _consecutiveFramesHandledCount - Running total of consecutive frames received and handled.\n * @private {array} _accumulator Combines incoming bytes from consecutive frames.\n */\nclass MessageFrameAssembler {\n    /**\n    * @constructor\n    * @param {cb} callback\n    */\n    constructor (callback) {\n        if (typeof callback !== 'function') {\n            throw new Error('Callback not of expected type (function) for MessageFrameAssembler');\n        }\n\n        this._callback = callback;\n\n        this._accumulator = [];\n        this._totalConsecutiveFrames = 0;\n        this._consecutiveFramesHandledCount = 0;\n        this._consecutiveFramesDataLength = 0;\n    }\n\n    /**\n     * Accepts a single frame or multiframe packet. The callback is used when the packet\n     * is completely read. For a single frame this is immediately. For a multi frame packet\n     * @param {SdlPacket} sdlPacket - Incoming sdl packet to be read.\n    */\n    handleFrame (sdlPacket) {\n        const frameType = sdlPacket.getFrameType();\n        // If the sdl packet is a single frame nothing needs to be assembled and this can be returned immediately.\n        if (frameType !== FrameType.FIRST && frameType !== FrameType.CONSECUTIVE) {\n            return this._callback(null, sdlPacket);\n        }\n        return this._handleMultiFrameMessage(sdlPacket);\n    }\n\n    /**\n     * Handles the first data frame. Sets the expected frame count and data length.\n     * @param {SdlPacket} sdlPacket\n     * @private\n     */\n    _handleFirstDataFrame (sdlPacket) {\n        /** @type {array} Array of uint8 */\n        const payload = sdlPacket.getPayload();\n\n        if (payload instanceof Uint8Array !== true || payload.length !== 8) {\n            throw new Error('Error handling first frame. Payload is an invalid length should be length 8.');\n        }\n        for (const byte in payload) {\n            if (byte < 0x00 || byte > 0xFF) {\n                throw new Error('Invalid payload. Must be an array of uint8 bytes.');\n            }\n        }\n\n        // first 4 8-bit integers contain the data length.\n        let dataLength = (payload[0] & 0x0F) << 24; // 8-bit x 3\n        dataLength += (payload[1] & 0xFF) << 16; // 8 x 2\n        dataLength += (payload[2] & 0xFF) << 8; // 8 x 1\n        dataLength += payload[3] & 0xFF; // 8 x 0\n\n        let frameCount = (payload[4] & 0xFF) << 24;\n        frameCount += (payload[5] & 0xFF) << 16;\n        frameCount += (payload[6] & 0xFF) << 8;\n        frameCount += payload[7] & 0xFF;\n\n        this._totalConsecutiveFrames = frameCount;\n        this._consecutiveFramesDataLength = dataLength;\n    }\n\n    /**\n     * First frame should be read in before this is called. Once the last\n     * frame is read, callback is used.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleConsecutiveFrame (sdlPacket) {\n        this._consecutiveFramesHandledCount++;\n\n        const frameType = sdlPacket.getFrameType();\n        /**\n         * frameSequence nth frame, or 0 for last frame,\n         * 8 bits are used to store this info so the count reverts to 1 after 255\n         * This doesn't affect reading the packet but it is notable if frame sequence is relied on.\n         */\n        const frameSequence = sdlPacket.getFrameInfo();\n\n        const payload = sdlPacket.getPayload();\n\n        for (const byte of payload) {\n            this._accumulator.push(byte);\n        }\n\n        // This is the last frame, finish things up and use callback.\n        if (frameSequence === 0) {\n            if (this._consecutiveFramesHandledCount !== this._totalConsecutiveFrames) {\n                console.warn(`Total frames expected ${this._totalConsecutiveFrames} does not match total frames received ${this._consecutiveFramesHandledCount}`);\n            }\n\n            if (this._consecutiveFramesDataLength !== this._accumulator.length) {\n                console.warn(`Total data expected ${this._consecutiveFramesDataLength} does not match total data received ${this._accumulator.length}`);\n            }\n\n            const finishedSdlPacket = new SdlPacket(\n                sdlPacket.getVersion(),\n                sdlPacket.getEncryption(),\n                frameType,\n                sdlPacket.getServiceType(),\n                frameSequence,\n                sdlPacket.getSessionID(),\n                this._accumulator.length,\n                sdlPacket.getMessageID(),\n                this._accumulator,\n                0, // no offset\n                this._accumulator.length // read the entire buffer\n            );\n\n            this._callback(null, finishedSdlPacket);\n        }\n    }\n\n    /**\n     * Handle the sdl packet based on its frame type, FIRST or CONSECUTIVE.\n     * Callback is used when final packet is read.\n     * @param {SdlPacket} sdlPacket - Sdl packet to be read.\n     */\n    _handleMultiFrameMessage (sdlPacket) {\n        const frameType = sdlPacket.getFrameType();\n        if (frameType === FrameType.FIRST) {\n            return this._handleFirstDataFrame(sdlPacket);\n        } else { // FrameType.Consecutive\n            return this._handleConsecutiveFrame(sdlPacket);\n        }\n    }\n}\n\n\n\nexport { MessageFrameAssembler };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass ControlFrameTags {\n}\n\n// hidden inner objects\n\nconst StartServiceACKBase = {\n    MTU: 'mtu',\n};\n\nconst NAKBase = {\n    REJECTED_PARAMS: 'rejectedParams',\n};\n\nconst StartServiceProtocolVersion = {\n    /** The negotiated version of the protocol. Must be in the format \"Major.Minor.Patch\"*/\n    PROTOCOL_VERSION: 'protocolVersion',\n};\n\nconst StartServiceHashId = {\n    /** Hash ID to identify this service and used when sending an EndService control frame*/\n    HASH_ID: 'hashId',\n};\n\nconst StartServiceDimensions = {\n    HEIGHT: 'height',\n    WIDTH: 'width',\n};\n\n// static members\n\nControlFrameTags.RPC = Object.freeze({\n    StartService: StartServiceProtocolVersion,\n\n    StartServiceACK: Object.assign({\n        /** HU allowed transport for secondary connection */\n        SECONDARY_TRANSPORTS: 'secondaryTransports',\n        /** HU allowed transports for audio and video services (1 == Primary, 2 == Secondary) */\n        AUDIO_SERVICE_TRANSPORTS: 'audioServiceTransports',\n        VIDEO_SERVICE_TRANSPORTS: 'videoServiceTransports',\n        /** Auth token to be used for log in into services **/\n        AUTH_TOKEN: 'authToken',\n    }, StartServiceACKBase, StartServiceProtocolVersion, StartServiceHashId),\n\n    StartServiceNAK: NAKBase,\n\n    EndService: StartServiceHashId,\n\n    EndServiceACK: {},\n\n    EndServiceNAK: NAKBase,\n\n    TransportEventUpdate: {\n        TCP_IP_ADDRESS: 'tcpIpAddress',\n        TCP_PORT: 'tcpPort',\n    },\n\n    RegisterSecondaryTransport: {},\n\n    RegisterSecondaryTransportACK: {},\n\n    RegisterSecondaryTransportNAK: Object.assign({\n        REASON: 'reason',\n    }, NAKBase),\n});\n\nControlFrameTags.Audio = Object.freeze({\n    StartService: {},\n\n    StartServiceACK: StartServiceACKBase,\n\n    StartServiceNAK: NAKBase,\n\n    EndService: {},\n\n    EndServiceACK: {},\n\n    EndServiceNAK: NAKBase,\n});\n\nControlFrameTags.Video = Object.freeze({\n    StartService: Object.assign({\n        VIDEO_PROTOCOL: 'videoProtocol',\n        VIDEO_CODEC: 'videoCodec',\n    }, StartServiceDimensions),\n\n    StartServiceACK: Object.assign({\n        VIDEO_PROTOCOL: 'videoProtocol',\n        VIDEO_CODEC: 'videoCodec',\n    }, StartServiceACKBase, StartServiceDimensions),\n\n    StartServiceNAK: NAKBase,\n\n    EndService: {},\n\n    EndServiceACK: {},\n\n    EndServiceNAK: NAKBase,\n});\n\nexport { ControlFrameTags };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass BitConverter {\n    /**\n\t * @param {ArrayBuffer} buffer - buffer that will be converted to int\n     * @param {Number} offset - int optional, the offset shift\n\t * @return {Number} int converted from buffer or -1 if buffer is null\n\t */\n    static arrayBufferToInt32 (buffer, offset = 0) {\n        if (!buffer) {\n            return -1;\n        }\n        const view = new DataView(buffer);\n        return view.getUint32(offset);\n    }\n\n    /**\n\t * @param {Number} value - the integer to be converted\n\t * @return {ArrayBuffer} buffer converted from input value\n\t */\n    static int32ToArrayBuffer (value) {\n        const buffer = new ArrayBuffer(4); // Int32 has 4 bytes\n        const view = new DataView(buffer);\n        view.setUint32(0, value, false);\n        return buffer;\n    }\n}\n\nexport { BitConverter };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SdlPacket } from './SdlPacket.js';\nimport { ControlFrameTags } from './enums/ControlFrameTags.js';\nimport { BitConverter } from './../util/BitConverter.js';\nimport { FrameType } from './enums/FrameType.js';\n\n/**\n * Creates control packets.\n * For regular RPC RPCMessage should be used.\n */\nclass SdlPacketFactory {\n    /**\n     * Creates a heartbeat acknowlegement packet.\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID\n     * @param {Number} version\n     * @returns {SdlPacket}\n     */\n    static createHeartbeatACK (serviceType, sessionID, version) {\n        return new SdlPacket(version, false, FrameType.CONTROL,\n            serviceType, SdlPacket.FRAME_INFO_HEART_BEAT_ACK, sessionID,\n            0, 0, null);\n    }\n\n    /**\n     * Creates an end session packet.\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID\n     * @param {Number} messageID\n     * @param {Number} version\n     * @param {Number} hashID\n     */\n    static createEndSession (serviceType, sessionID, messageID, version, hashID) {\n        if (version < 5) {\n            const payload = new Uint8Array(BitConverter.int32ToArrayBuffer(hashID));\n            return new SdlPacket(version, false, FrameType.CONTROL,\n                serviceType, SdlPacket.FRAME_INFO_END_SERVICE, sessionID,\n                payload.length, messageID, payload, 0, payload.length);\n        } else {\n            const endSession = new SdlPacket(version, false, FrameType.CONTROL,\n                serviceType, SdlPacket.FRAME_INFO_END_SERVICE, sessionID,\n                0, messageID, null);\n            endSession.putTag(ControlFrameTags.RPC.EndService.HASH_ID, hashID);\n            return endSession;\n        }\n    }\n}\n\nexport { SdlPacketFactory };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Contains information about a SoftButton's capabilities.\n */\nclass SoftButtonCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} available - The button supports a short press. Whenever the button is pressed short,\n     *                              onButtonPressed( SHORT) will be invoked.\n     * @return {SoftButtonCapabilities}\n     */\n    setShortPressAvailable (available) {\n        this.setParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getShortPressAvailable () {\n        return this.getParameter(SoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - The button supports a LONG press. Whenever the button is pressed long,\n     *                              onButtonPressed( LONG) will be invoked.\n     * @return {SoftButtonCapabilities}\n     */\n    setLongPressAvailable (available) {\n        this.setParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getLongPressAvailable () {\n        return this.getParameter(SoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - The button supports \"button down\" and \"button up\". Whenever the button is pressed,\n     *                              onButtonEvent( DOWN) will be invoked. Whenever the button is released,\n     *                              onButtonEvent( UP) will be invoked.\n     * @return {SoftButtonCapabilities}\n     */\n    setUpDownAvailable (available) {\n        this.setParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getUpDownAvailable () {\n        return this.getParameter(SoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} supported - The button supports referencing a static or dynamic image.\n     * @return {SoftButtonCapabilities}\n     */\n    setImageSupported (supported) {\n        this.setParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getImageSupported () {\n        return this.getParameter(SoftButtonCapabilities.KEY_IMAGE_SUPPORTED);\n    }\n\n    /**\n     * @param {Boolean} supported - The button supports the use of text. If not included, the default value should be\n     *                              considered true that the button will support text.\n     * @return {SoftButtonCapabilities}\n     */\n    setTextSupported (supported) {\n        this.setParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTextSupported () {\n        return this.getParameter(SoftButtonCapabilities.KEY_TEXT_SUPPORTED);\n    }\n}\n\nSoftButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable';\nSoftButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable';\nSoftButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable';\nSoftButtonCapabilities.KEY_IMAGE_SUPPORTED = 'imageSupported';\nSoftButtonCapabilities.KEY_TEXT_SUPPORTED = 'textSupported';\n\nexport { SoftButtonCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Contains a list of prerecorded speech items present on the platform.\n * @typedef {Enum} PrerecordedSpeech\n * @property {Object} _MAP\n */\nclass PrerecordedSpeech extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HELP_JINGLE () {\n        return PrerecordedSpeech._MAP.HELP_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INITIAL_JINGLE () {\n        return PrerecordedSpeech._MAP.INITIAL_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LISTEN_JINGLE () {\n        return PrerecordedSpeech._MAP.LISTEN_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get POSITIVE_JINGLE () {\n        return PrerecordedSpeech._MAP.POSITIVE_JINGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NEGATIVE_JINGLE () {\n        return PrerecordedSpeech._MAP.NEGATIVE_JINGLE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PrerecordedSpeech._valueForKey(key, PrerecordedSpeech._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PrerecordedSpeech._keyForValue(value, PrerecordedSpeech._MAP);\n    }\n}\n\nPrerecordedSpeech._MAP = Object.freeze({\n    'HELP_JINGLE': 'HELP_JINGLE',\n    'INITIAL_JINGLE': 'INITIAL_JINGLE',\n    'LISTEN_JINGLE': 'LISTEN_JINGLE',\n    'POSITIVE_JINGLE': 'POSITIVE_JINGLE',\n    'NEGATIVE_JINGLE': 'NEGATIVE_JINGLE',\n});\n\nexport { PrerecordedSpeech };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Contains information about on-screen preset capabilities.\n */\nclass PresetBankCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} available - Onscreen custom presets are available.\n     * @return {PresetBankCapabilities}\n     */\n    setOnScreenPresetsAvailable (available) {\n        this.setParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getOnScreenPresetsAvailable () {\n        return this.getParameter(PresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE);\n    }\n}\n\nPresetBankCapabilities.KEY_ON_SCREEN_PRESETS_AVAILABLE = 'onScreenPresetsAvailable';\n\nexport { PresetBankCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass VehicleType extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} make - Make of the vehicle, e.g. Ford\n     * @return {VehicleType}\n     */\n    setMake (make) {\n        this.setParameter(VehicleType.KEY_MAKE, make);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMake () {\n        return this.getParameter(VehicleType.KEY_MAKE);\n    }\n\n    /**\n     * @param {String} model - Model of the vehicle, e.g. Fiesta\n     * @return {VehicleType}\n     */\n    setModel (model) {\n        this.setParameter(VehicleType.KEY_MODEL, model);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModel () {\n        return this.getParameter(VehicleType.KEY_MODEL);\n    }\n\n    /**\n     * @param {String} year - Model Year of the vehicle, e.g. 2013\n     * @return {VehicleType}\n     */\n    setModelYear (year) {\n        this.setParameter(VehicleType.KEY_MODEL_YEAR, year);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModelYear () {\n        return this.getParameter(VehicleType.KEY_MODEL_YEAR);\n    }\n\n    /**\n     * @param {String} trim - Trim of the vehicle, e.g. SE\n     * @return {VehicleType}\n     */\n    setTrim (trim) {\n        this.setParameter(VehicleType.KEY_TRIM, trim);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getTrim () {\n        return this.getParameter(VehicleType.KEY_TRIM);\n    }\n}\n\nVehicleType.KEY_MAKE = 'make';\nVehicleType.KEY_MODEL = 'model';\nVehicleType.KEY_MODEL_YEAR = 'modelYear';\nVehicleType.KEY_TRIM = 'trim';\n\nexport { VehicleType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Contains information about the HMI zone capabilities. For future use.\n * @typedef {Enum} HmiZoneCapabilities\n * @property {Object} _MAP\n */\nclass HmiZoneCapabilities extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FRONT () {\n        return HmiZoneCapabilities._MAP.FRONT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BACK () {\n        return HmiZoneCapabilities._MAP.BACK;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return HmiZoneCapabilities._valueForKey(key, HmiZoneCapabilities._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return HmiZoneCapabilities._keyForValue(value, HmiZoneCapabilities._MAP);\n    }\n}\n\nHmiZoneCapabilities._MAP = Object.freeze({\n    'FRONT': 'FRONT',\n    'BACK': 'BACK',\n});\n\nexport { HmiZoneCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} MediaClockFormat\n * @property {Object} _MAP\n */\nclass MediaClockFormat extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * minutesFieldWidth = 2;minutesFieldMax = 19;secondsFieldWidth = 2;secondsFieldMax = 99;maxHours = 19;maxMinutes\n     * = 59;maxSeconds = 59; used for Type II and CID headunits\n     * @return {String}\n     */\n    static get CLOCK1 () {\n        return MediaClockFormat._MAP.CLOCK1;\n    }\n\n    /**\n     * minutesFieldWidth = 3;minutesFieldMax = 199;secondsFieldWidth = 2;secondsFieldMax = 99;maxHours = 59;maxMinutes\n     * = 59;maxSeconds = 59; used for Type V headunit\n     * @return {String}\n     */\n    static get CLOCK2 () {\n        return MediaClockFormat._MAP.CLOCK2;\n    }\n\n    /**\n     * minutesFieldWidth = 2;minutesFieldMax = 59;secondsFieldWidth = 2;secondsFieldMax = 59;maxHours = 9;maxMinutes =\n     * 59;maxSeconds = 59; used for GEN1.1 MFD3/4/5 headunits\n     * @return {String}\n     */\n    static get CLOCK3 () {\n        return MediaClockFormat._MAP.CLOCK3;\n    }\n\n    /**\n     * 5 characters possible Format: 1|sp c :|sp c c 1|sp : digit \"1\" or space c : character out of following\n     * character set: sp|0-9|[letters, see TypeII column in XLS. See :|sp : colon or space used for Type II headunit\n     * @return {String}\n     */\n    static get CLOCKTEXT1 () {\n        return MediaClockFormat._MAP.CLOCKTEXT1;\n    }\n\n    /**\n     * 5 chars possible Format: 1|sp c :|sp c c 1|sp : digit \"1\" or space c : character out of following character\n     * set: sp|0-9|[letters, see CID column in XLS. See :|sp : colon or space used for CID headunit NOTE: difference\n     * between CLOCKTEXT1 and CLOCKTEXT2 is the supported character set\n     * @return {String}\n     */\n    static get CLOCKTEXT2 () {\n        return MediaClockFormat._MAP.CLOCKTEXT2;\n    }\n\n    /**\n     * 6 chars possible Format: 1|sp c c :|sp c c 1|sp : digit \"1\" or space c : character out of following character\n     * set: sp|0-9|[letters, see Type 5 column in XLS]. See :|sp : colon or space used for Type V headunit\n     * @return {String}\n     */\n    static get CLOCKTEXT3 () {\n        return MediaClockFormat._MAP.CLOCKTEXT3;\n    }\n\n    /**\n     * 6 chars possible Format: c :|sp c c : c c :|sp : colon or space c : character out of following character set:\n     * sp|0-9|[letters]. used for GEN1.1 MFD3/4/5 headunits\n     * @return {String}\n     */\n    static get CLOCKTEXT4 () {\n        return MediaClockFormat._MAP.CLOCKTEXT4;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MediaClockFormat._valueForKey(key, MediaClockFormat._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MediaClockFormat._keyForValue(value, MediaClockFormat._MAP);\n    }\n}\n\nMediaClockFormat._MAP = Object.freeze({\n    'CLOCK1': 'CLOCK1',\n    'CLOCK2': 'CLOCK2',\n    'CLOCK3': 'CLOCK3',\n    'CLOCKTEXT1': 'CLOCKTEXT1',\n    'CLOCKTEXT2': 'CLOCKTEXT2',\n    'CLOCKTEXT3': 'CLOCKTEXT3',\n    'CLOCKTEXT4': 'CLOCKTEXT4',\n});\n\nexport { MediaClockFormat };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass ImageResolution extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} width - The image resolution width.\n     * @return {ImageResolution}\n     */\n    setResolutionWidth (width) {\n        this.setParameter(ImageResolution.KEY_RESOLUTION_WIDTH, width);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getResolutionWidth () {\n        return this.getParameter(ImageResolution.KEY_RESOLUTION_WIDTH);\n    }\n\n    /**\n     * @param {Number} height - The image resolution height.\n     * @return {ImageResolution}\n     */\n    setResolutionHeight (height) {\n        this.setParameter(ImageResolution.KEY_RESOLUTION_HEIGHT, height);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getResolutionHeight () {\n        return this.getParameter(ImageResolution.KEY_RESOLUTION_HEIGHT);\n    }\n}\n\nImageResolution.KEY_RESOLUTION_WIDTH = 'resolutionWidth';\nImageResolution.KEY_RESOLUTION_HEIGHT = 'resolutionHeight';\n\nexport { ImageResolution };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass TouchEventCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {TouchEventCapabilities}\n     */\n    setPressAvailable (available) {\n        this.setParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPressAvailable () {\n        return this.getParameter(TouchEventCapabilities.KEY_PRESS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {TouchEventCapabilities}\n     */\n    setMultiTouchAvailable (available) {\n        this.setParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMultiTouchAvailable () {\n        return this.getParameter(TouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {TouchEventCapabilities}\n     */\n    setDoublePressAvailable (available) {\n        this.setParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDoublePressAvailable () {\n        return this.getParameter(TouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE);\n    }\n}\n\nTouchEventCapabilities.KEY_PRESS_AVAILABLE = 'pressAvailable';\nTouchEventCapabilities.KEY_MULTI_TOUCH_AVAILABLE = 'multiTouchAvailable';\nTouchEventCapabilities.KEY_DOUBLE_PRESS_AVAILABLE = 'doublePressAvailable';\n\nexport { TouchEventCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ImageResolution } from './ImageResolution.js';\nimport { TouchEventCapabilities } from './TouchEventCapabilities.js';\n\nclass ScreenParams extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ImageResolution} resolution - The resolution of the prescribed screen area.\n     * @return {ScreenParams}\n     */\n    setResolution (resolution) {\n        this.validateType(ImageResolution, resolution);\n        this.setParameter(ScreenParams.KEY_RESOLUTION, resolution);\n        return this;\n    }\n\n    /**\n     * @return {ImageResolution}\n     */\n    getResolution () {\n        return this.getObject(ImageResolution, ScreenParams.KEY_RESOLUTION);\n    }\n\n    /**\n     * @param {TouchEventCapabilities} available - Types of screen touch events available in screen area.\n     * @return {ScreenParams}\n     */\n    setTouchEventAvailable (available) {\n        this.validateType(TouchEventCapabilities, available);\n        this.setParameter(ScreenParams.KEY_TOUCH_EVENT_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {TouchEventCapabilities}\n     */\n    getTouchEventAvailable () {\n        return this.getObject(TouchEventCapabilities, ScreenParams.KEY_TOUCH_EVENT_AVAILABLE);\n    }\n}\n\nScreenParams.KEY_RESOLUTION = 'resolution';\nScreenParams.KEY_TOUCH_EVENT_AVAILABLE = 'touchEventAvailable';\n\nexport { ScreenParams };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ImageFieldName\n * @property {Object} _MAP\n */\nclass ImageFieldName extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The image field for SoftButton\n     * @return {String}\n     */\n    static get softButtonImage () {\n        return ImageFieldName._MAP.softButtonImage;\n    }\n\n    /**\n     * The first image field for Choice\n     * @return {String}\n     */\n    static get choiceImage () {\n        return ImageFieldName._MAP.choiceImage;\n    }\n\n    /**\n     * The secondary image field for Choice\n     * @return {String}\n     */\n    static get choiceSecondaryImage () {\n        return ImageFieldName._MAP.choiceSecondaryImage;\n    }\n\n    /**\n     * The image field for vrHelpItem\n     * @return {String}\n     */\n    static get vrHelpItem () {\n        return ImageFieldName._MAP.vrHelpItem;\n    }\n\n    /**\n     * The image field for Turn\n     * @return {String}\n     */\n    static get turnIcon () {\n        return ImageFieldName._MAP.turnIcon;\n    }\n\n    /**\n     * The image field for the menu icon in SetGlobalProperties\n     * @return {String}\n     */\n    static get menuIcon () {\n        return ImageFieldName._MAP.menuIcon;\n    }\n\n    /**\n     * The image field for AddCommand\n     * @return {String}\n     */\n    static get cmdIcon () {\n        return ImageFieldName._MAP.cmdIcon;\n    }\n\n    /**\n     * The image field for the app icon (set by setAppIcon)\n     * @return {String}\n     */\n    static get appIcon () {\n        return ImageFieldName._MAP.appIcon;\n    }\n\n    /**\n     * The primary image field for Show\n     * @return {String}\n     */\n    static get graphic () {\n        return ImageFieldName._MAP.graphic;\n    }\n\n    /**\n     * The secondary image field for Show\n     * @return {String}\n     */\n    static get secondaryGraphic () {\n        return ImageFieldName._MAP.secondaryGraphic;\n    }\n\n    /**\n     * The primary image field for ShowConstantTBT\n     * @return {String}\n     */\n    static get showConstantTBTIcon () {\n        return ImageFieldName._MAP.showConstantTBTIcon;\n    }\n\n    /**\n     * The secondary image field for ShowConstantTBT\n     * @return {String}\n     */\n    static get showConstantTBTNextTurnIcon () {\n        return ImageFieldName._MAP.showConstantTBTNextTurnIcon;\n    }\n\n    /**\n     * The optional image of a destination / location\n     * @return {String}\n     */\n    static get locationImage () {\n        return ImageFieldName._MAP.locationImage;\n    }\n\n    /**\n     * The image field for Alert\n     * @return {String}\n     */\n    static get alertIcon () {\n        return ImageFieldName._MAP.alertIcon;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ImageFieldName._valueForKey(key, ImageFieldName._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ImageFieldName._keyForValue(value, ImageFieldName._MAP);\n    }\n}\n\nImageFieldName._MAP = Object.freeze({\n    'softButtonImage': 'softButtonImage',\n    'choiceImage': 'choiceImage',\n    'choiceSecondaryImage': 'choiceSecondaryImage',\n    'vrHelpItem': 'vrHelpItem',\n    'turnIcon': 'turnIcon',\n    'menuIcon': 'menuIcon',\n    'cmdIcon': 'cmdIcon',\n    'appIcon': 'appIcon',\n    'graphic': 'graphic',\n    'secondaryGraphic': 'secondaryGraphic',\n    'showConstantTBTIcon': 'showConstantTBTIcon',\n    'showConstantTBTNextTurnIcon': 'showConstantTBTNextTurnIcon',\n    'locationImage': 'locationImage',\n    'alertIcon': 'alertIcon',\n});\n\nexport { ImageFieldName };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration listing possible file types.\n * @typedef {Enum} FileType\n * @property {Object} _MAP\n */\nclass FileType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GRAPHIC_BMP () {\n        return FileType._MAP.GRAPHIC_BMP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GRAPHIC_JPEG () {\n        return FileType._MAP.GRAPHIC_JPEG;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GRAPHIC_PNG () {\n        return FileType._MAP.GRAPHIC_PNG;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIO_WAVE () {\n        return FileType._MAP.AUDIO_WAVE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIO_MP3 () {\n        return FileType._MAP.AUDIO_MP3;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIO_AAC () {\n        return FileType._MAP.AUDIO_AAC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BINARY () {\n        return FileType._MAP.BINARY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get JSON () {\n        return FileType._MAP.JSON;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return FileType._valueForKey(key, FileType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return FileType._keyForValue(value, FileType._MAP);\n    }\n}\n\nFileType._MAP = Object.freeze({\n    'GRAPHIC_BMP': 'GRAPHIC_BMP',\n    'GRAPHIC_JPEG': 'GRAPHIC_JPEG',\n    'GRAPHIC_PNG': 'GRAPHIC_PNG',\n    'AUDIO_WAVE': 'AUDIO_WAVE',\n    'AUDIO_MP3': 'AUDIO_MP3',\n    'AUDIO_AAC': 'AUDIO_AAC',\n    'BINARY': 'BINARY',\n    'JSON': 'JSON',\n});\n\nexport { FileType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ImageResolution } from './ImageResolution.js';\nimport { ImageFieldName } from '../enums/ImageFieldName.js';\nimport { FileType } from '../enums/FileType.js';\n\nclass ImageField extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ImageFieldName} name - The name that identifies the field. See ImageFieldName.\n     * @return {ImageField}\n     */\n    setName (name) {\n        this.validateType(ImageFieldName, name);\n        this.setParameter(ImageField.KEY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {ImageFieldName}\n     */\n    getName () {\n        return this.getObject(ImageFieldName, ImageField.KEY_NAME);\n    }\n\n    /**\n     * @param {FileType[]} supported - The image types that are supported in this field. See FileType.\n     * @return {ImageField}\n     */\n    setImageTypeSupported (supported) {\n        this.validateType(FileType, supported, true);\n        this.setParameter(ImageField.KEY_IMAGE_TYPE_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {FileType[]}\n     */\n    getImageTypeSupported () {\n        return this.getObject(FileType, ImageField.KEY_IMAGE_TYPE_SUPPORTED);\n    }\n\n    /**\n     * @param {ImageResolution} resolution - The image resolution of this field.\n     * @return {ImageField}\n     */\n    setImageResolution (resolution) {\n        this.validateType(ImageResolution, resolution);\n        this.setParameter(ImageField.KEY_IMAGE_RESOLUTION, resolution);\n        return this;\n    }\n\n    /**\n     * @return {ImageResolution}\n     */\n    getImageResolution () {\n        return this.getObject(ImageResolution, ImageField.KEY_IMAGE_RESOLUTION);\n    }\n}\n\nImageField.KEY_NAME = 'name';\nImageField.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported';\nImageField.KEY_IMAGE_RESOLUTION = 'imageResolution';\n\nexport { ImageField };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * See DAES for further infos regarding the displays\n * @deprecated\n * @typedef {Enum} DisplayType\n * @property {Object} _MAP\n */\nclass DisplayType extends Enum {\n    /**\n     * @deprecated\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get CID () {\n        return DisplayType._MAP.CID;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get TYPE2 () {\n        return DisplayType._MAP.TYPE2;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get TYPE5 () {\n        return DisplayType._MAP.TYPE5;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get NGN () {\n        return DisplayType._MAP.NGN;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get GEN2_8_DMA () {\n        return DisplayType._MAP.GEN2_8_DMA;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get GEN2_6_DMA () {\n        return DisplayType._MAP.GEN2_6_DMA;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get MFD3 () {\n        return DisplayType._MAP.MFD3;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get MFD4 () {\n        return DisplayType._MAP.MFD4;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get MFD5 () {\n        return DisplayType._MAP.MFD5;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get GEN3_8_INCH () {\n        return DisplayType._MAP.GEN3_8_INCH;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get SDL_GENERIC () {\n        return DisplayType._MAP.SDL_GENERIC;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return DisplayType._valueForKey(key, DisplayType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return DisplayType._keyForValue(value, DisplayType._MAP);\n    }\n}\n\nDisplayType._MAP = Object.freeze({\n    'CID': 'CID',\n    'TYPE2': 'TYPE2',\n    'TYPE5': 'TYPE5',\n    'NGN': 'NGN',\n    'GEN2_8_DMA': 'GEN2_8_DMA',\n    'GEN2_6_DMA': 'GEN2_6_DMA',\n    'MFD3': 'MFD3',\n    'MFD4': 'MFD4',\n    'MFD5': 'MFD5',\n    'GEN3_8_INCH': 'GEN3_8-INCH',\n    'SDL_GENERIC': 'SDL_GENERIC',\n});\n\nexport { DisplayType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TextFieldName\n * @property {Object} _MAP\n */\nclass TextFieldName extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The first line of first set of main fields of the persistent display; applies to \"Show\"\n     * @return {String}\n     */\n    static get mainField1 () {\n        return TextFieldName._MAP.mainField1;\n    }\n\n    /**\n     * The second line of first set of main fields of the persistent display; applies to \"Show\"\n     * @return {String}\n     */\n    static get mainField2 () {\n        return TextFieldName._MAP.mainField2;\n    }\n\n    /**\n     * The first line of second set of main fields of persistent display; applies to \"Show\"\n     * @return {String}\n     */\n    static get mainField3 () {\n        return TextFieldName._MAP.mainField3;\n    }\n\n    /**\n     * The second line of second set of main fields of the persistent display; applies to \"Show\"\n     * @return {String}\n     */\n    static get mainField4 () {\n        return TextFieldName._MAP.mainField4;\n    }\n\n    /**\n     * The status bar on NGN; applies to \"Show\"\n     * @return {String}\n     */\n    static get statusBar () {\n        return TextFieldName._MAP.statusBar;\n    }\n\n    /**\n     * Text value for MediaClock field; applies to \"Show\"\n     * @return {String}\n     */\n    static get mediaClock () {\n        return TextFieldName._MAP.mediaClock;\n    }\n\n    /**\n     * The track field of NGN and GEN1.1 MFD displays. This field is only available for media applications; applies to\n     * \"Show\"\n     * @return {String}\n     */\n    static get mediaTrack () {\n        return TextFieldName._MAP.mediaTrack;\n    }\n\n    /**\n     * The title of the new template that will be displayed; applies to \"Show\"\n     * @return {String}\n     */\n    static get templateTitle () {\n        return TextFieldName._MAP.templateTitle;\n    }\n\n    /**\n     * The first line of the alert text field; applies to \"Alert\"\n     * @return {String}\n     */\n    static get alertText1 () {\n        return TextFieldName._MAP.alertText1;\n    }\n\n    /**\n     * The second line of the alert text field; applies to \"Alert\"\n     * @return {String}\n     */\n    static get alertText2 () {\n        return TextFieldName._MAP.alertText2;\n    }\n\n    /**\n     * The third line of the alert text field; applies to \"Alert\"\n     * @return {String}\n     */\n    static get alertText3 () {\n        return TextFieldName._MAP.alertText3;\n    }\n\n    /**\n     * Long form body of text that can include newlines and tabs; applies to \"ScrollableMessage\"\n     * @return {String}\n     */\n    static get scrollableMessageBody () {\n        return TextFieldName._MAP.scrollableMessageBody;\n    }\n\n    /**\n     * First line suggestion for a user response (in the case of VR enabled interaction)\n     * @return {String}\n     */\n    static get initialInteractionText () {\n        return TextFieldName._MAP.initialInteractionText;\n    }\n\n    /**\n     * First line of navigation text\n     * @return {String}\n     */\n    static get navigationText1 () {\n        return TextFieldName._MAP.navigationText1;\n    }\n\n    /**\n     * Second line of navigation text\n     * @return {String}\n     */\n    static get navigationText2 () {\n        return TextFieldName._MAP.navigationText2;\n    }\n\n    /**\n     * Estimated Time of Arrival time for navigation\n     * @return {String}\n     */\n    static get ETA () {\n        return TextFieldName._MAP.ETA;\n    }\n\n    /**\n     * Total distance to destination for navigation\n     * @return {String}\n     */\n    static get totalDistance () {\n        return TextFieldName._MAP.totalDistance;\n    }\n\n    /**\n     * First line of text for audio pass thru\n     * @return {String}\n     */\n    static get audioPassThruDisplayText1 () {\n        return TextFieldName._MAP.audioPassThruDisplayText1;\n    }\n\n    /**\n     * Second line of text for audio pass thru\n     * @return {String}\n     */\n    static get audioPassThruDisplayText2 () {\n        return TextFieldName._MAP.audioPassThruDisplayText2;\n    }\n\n    /**\n     * Header text for slider\n     * @return {String}\n     */\n    static get sliderHeader () {\n        return TextFieldName._MAP.sliderHeader;\n    }\n\n    /**\n     * Footer text for slider\n     * @return {String}\n     */\n    static get sliderFooter () {\n        return TextFieldName._MAP.sliderFooter;\n    }\n\n    /**\n     * Primary text for Choice\n     * @return {String}\n     */\n    static get menuName () {\n        return TextFieldName._MAP.menuName;\n    }\n\n    /**\n     * Secondary text for Choice\n     * @return {String}\n     */\n    static get secondaryText () {\n        return TextFieldName._MAP.secondaryText;\n    }\n\n    /**\n     * Tertiary text for Choice\n     * @return {String}\n     */\n    static get tertiaryText () {\n        return TextFieldName._MAP.tertiaryText;\n    }\n\n    /**\n     * Optional text to label an app menu button (for certain touchscreen platforms).\n     * @return {String}\n     */\n    static get menuTitle () {\n        return TextFieldName._MAP.menuTitle;\n    }\n\n    /**\n     * Optional name / title of intended location for SendLocation.\n     * @return {String}\n     */\n    static get locationName () {\n        return TextFieldName._MAP.locationName;\n    }\n\n    /**\n     * Optional description of intended location / establishment (if applicable) for SendLocation.\n     * @return {String}\n     */\n    static get locationDescription () {\n        return TextFieldName._MAP.locationDescription;\n    }\n\n    /**\n     * Optional location address (if applicable) for SendLocation.\n     * @return {String}\n     */\n    static get addressLines () {\n        return TextFieldName._MAP.addressLines;\n    }\n\n    /**\n     * Optional hone number of intended location / establishment (if applicable) for SendLocation.\n     * @return {String}\n     */\n    static get phoneNumber () {\n        return TextFieldName._MAP.phoneNumber;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TextFieldName._valueForKey(key, TextFieldName._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TextFieldName._keyForValue(value, TextFieldName._MAP);\n    }\n}\n\nTextFieldName._MAP = Object.freeze({\n    'mainField1': 'mainField1',\n    'mainField2': 'mainField2',\n    'mainField3': 'mainField3',\n    'mainField4': 'mainField4',\n    'statusBar': 'statusBar',\n    'mediaClock': 'mediaClock',\n    'mediaTrack': 'mediaTrack',\n    'templateTitle': 'templateTitle',\n    'alertText1': 'alertText1',\n    'alertText2': 'alertText2',\n    'alertText3': 'alertText3',\n    'scrollableMessageBody': 'scrollableMessageBody',\n    'initialInteractionText': 'initialInteractionText',\n    'navigationText1': 'navigationText1',\n    'navigationText2': 'navigationText2',\n    'ETA': 'ETA',\n    'totalDistance': 'totalDistance',\n    'audioPassThruDisplayText1': 'audioPassThruDisplayText1',\n    'audioPassThruDisplayText2': 'audioPassThruDisplayText2',\n    'sliderHeader': 'sliderHeader',\n    'sliderFooter': 'sliderFooter',\n    'menuName': 'menuName',\n    'secondaryText': 'secondaryText',\n    'tertiaryText': 'tertiaryText',\n    'menuTitle': 'menuTitle',\n    'locationName': 'locationName',\n    'locationDescription': 'locationDescription',\n    'addressLines': 'addressLines',\n    'phoneNumber': 'phoneNumber',\n});\n\nexport { TextFieldName };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The list of potential character sets\n * @typedef {Enum} CharacterSet\n * @property {Object} _MAP\n */\nclass CharacterSet extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * See\n     * @return {String}\n     */\n    static get TYPE2SET () {\n        return CharacterSet._MAP.TYPE2SET;\n    }\n\n    /**\n     * See\n     * @return {String}\n     */\n    static get TYPE5SET () {\n        return CharacterSet._MAP.TYPE5SET;\n    }\n\n    /**\n     * See\n     * @return {String}\n     */\n    static get CID1SET () {\n        return CharacterSet._MAP.CID1SET;\n    }\n\n    /**\n     * See\n     * @return {String}\n     */\n    static get CID2SET () {\n        return CharacterSet._MAP.CID2SET;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return CharacterSet._valueForKey(key, CharacterSet._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return CharacterSet._keyForValue(value, CharacterSet._MAP);\n    }\n}\n\nCharacterSet._MAP = Object.freeze({\n    'TYPE2SET': 'TYPE2SET',\n    'TYPE5SET': 'TYPE5SET',\n    'CID1SET': 'CID1SET',\n    'CID2SET': 'CID2SET',\n});\n\nexport { CharacterSet };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TextFieldName } from '../enums/TextFieldName.js';\nimport { CharacterSet } from '../enums/CharacterSet.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass TextField extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {TextFieldName} name - The name that identifies the field. See TextFieldName.\n     * @return {TextField}\n     */\n    setName (name) {\n        this.validateType(TextFieldName, name);\n        this.setParameter(TextField.KEY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {TextFieldName}\n     */\n    getName () {\n        return this.getObject(TextFieldName, TextField.KEY_NAME);\n    }\n\n    /**\n     * @param {CharacterSet} set - The character set that is supported in this field. See CharacterSet.\n     * @return {TextField}\n     */\n    setCharacterSet (set) {\n        this.validateType(CharacterSet, set);\n        this.setParameter(TextField.KEY_CHARACTER_SET, set);\n        return this;\n    }\n\n    /**\n     * @return {CharacterSet}\n     */\n    getCharacterSet () {\n        return this.getObject(CharacterSet, TextField.KEY_CHARACTER_SET);\n    }\n\n    /**\n     * @param {Number} width - The number of characters in one row of this field.\n     * @return {TextField}\n     */\n    setWidth (width) {\n        this.setParameter(TextField.KEY_WIDTH, width);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWidth () {\n        return this.getParameter(TextField.KEY_WIDTH);\n    }\n\n    /**\n     * @param {Number} rows - The number of rows of this field.\n     * @return {TextField}\n     */\n    setRows (rows) {\n        this.setParameter(TextField.KEY_ROWS, rows);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRows () {\n        return this.getParameter(TextField.KEY_ROWS);\n    }\n}\n\nTextField.KEY_NAME = 'name';\nTextField.KEY_CHARACTER_SET = 'characterSet';\nTextField.KEY_WIDTH = 'width';\nTextField.KEY_ROWS = 'rows';\n\nexport { TextField };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { MediaClockFormat } from '../enums/MediaClockFormat.js';\nimport { ScreenParams } from './ScreenParams.js';\nimport { ImageField } from './ImageField.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { DisplayType } from '../enums/DisplayType.js';\nimport { TextField } from './TextField.js';\n\n/**\n * Contains information about the display capabilities. This struct is deprecated; please see the new SystemCapability\n * DISPLAYS and corresponding struct DisplayCapability\n * @deprecated\n */\nclass DisplayCapabilities extends RpcStruct {\n    /**\n     * @deprecated\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @deprecated\n     * @param {DisplayType} type - The type of the display. See DisplayType\n     * @return {DisplayCapabilities}\n     */\n    setDisplayType (type) {\n        this.validateType(DisplayType, type);\n        this.setParameter(DisplayCapabilities.KEY_DISPLAY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {DisplayType}\n     */\n    getDisplayType () {\n        return this.getObject(DisplayType, DisplayCapabilities.KEY_DISPLAY_TYPE);\n    }\n\n    /**\n     * @deprecated\n     * @param {String} name - The name of the display the app is connected to.\n     * @return {DisplayCapabilities}\n     */\n    setDisplayName (name) {\n        this.setParameter(DisplayCapabilities.KEY_DISPLAY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    getDisplayName () {\n        return this.getParameter(DisplayCapabilities.KEY_DISPLAY_NAME);\n    }\n\n    /**\n     * @deprecated\n     * @param {TextField[]} fields - A set of all fields that support text data. See TextField\n     * @return {DisplayCapabilities}\n     */\n    setTextFields (fields) {\n        this.validateType(TextField, fields, true);\n        this.setParameter(DisplayCapabilities.KEY_TEXT_FIELDS, fields);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {TextField[]}\n     */\n    getTextFields () {\n        return this.getObject(TextField, DisplayCapabilities.KEY_TEXT_FIELDS);\n    }\n\n    /**\n     * @deprecated\n     * @param {ImageField[]} fields - A set of all fields that support images. See ImageField\n     * @return {DisplayCapabilities}\n     */\n    setImageFields (fields) {\n        this.validateType(ImageField, fields, true);\n        this.setParameter(DisplayCapabilities.KEY_IMAGE_FIELDS, fields);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {ImageField[]}\n     */\n    getImageFields () {\n        return this.getObject(ImageField, DisplayCapabilities.KEY_IMAGE_FIELDS);\n    }\n\n    /**\n     * @deprecated\n     * @param {MediaClockFormat[]} formats - A set of all supported formats of the media clock. See MediaClockFormat\n     * @return {DisplayCapabilities}\n     */\n    setMediaClockFormats (formats) {\n        this.validateType(MediaClockFormat, formats, true);\n        this.setParameter(DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS, formats);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {MediaClockFormat[]}\n     */\n    getMediaClockFormats () {\n        return this.getObject(MediaClockFormat, DisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS);\n    }\n\n    /**\n     * @deprecated\n     * @param {Boolean} supported - The display's persistent screen supports referencing a static or dynamic image.\n     * @return {DisplayCapabilities}\n     */\n    setGraphicSupported (supported) {\n        this.setParameter(DisplayCapabilities.KEY_GRAPHIC_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {Boolean}\n     */\n    getGraphicSupported () {\n        return this.getParameter(DisplayCapabilities.KEY_GRAPHIC_SUPPORTED);\n    }\n\n    /**\n     * @deprecated\n     * @param {String[]} available - A set of all predefined persistent display templates available on headunit. To be\n     *                               referenced in SetDisplayLayout.\n     * @return {DisplayCapabilities}\n     */\n    setTemplatesAvailable (available) {\n        this.setParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {String[]}\n     */\n    getTemplatesAvailable () {\n        return this.getParameter(DisplayCapabilities.KEY_TEMPLATES_AVAILABLE);\n    }\n\n    /**\n     * @deprecated\n     * @param {ScreenParams} params - A set of all parameters related to a prescribed screen area (e.g. for video /\n     *                                touch input).\n     * @return {DisplayCapabilities}\n     */\n    setScreenParams (params) {\n        this.validateType(ScreenParams, params);\n        this.setParameter(DisplayCapabilities.KEY_SCREEN_PARAMS, params);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {ScreenParams}\n     */\n    getScreenParams () {\n        return this.getObject(ScreenParams, DisplayCapabilities.KEY_SCREEN_PARAMS);\n    }\n\n    /**\n     * @deprecated\n     * @param {Number} available - The number of on-screen custom presets available (if any); otherwise omitted.\n     * @return {DisplayCapabilities}\n     */\n    setNumCustomPresetsAvailable (available) {\n        this.setParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {Number}\n     */\n    getNumCustomPresetsAvailable () {\n        return this.getParameter(DisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE);\n    }\n}\n\nDisplayCapabilities.KEY_DISPLAY_TYPE = 'displayType';\nDisplayCapabilities.KEY_DISPLAY_NAME = 'displayName';\nDisplayCapabilities.KEY_TEXT_FIELDS = 'textFields';\nDisplayCapabilities.KEY_IMAGE_FIELDS = 'imageFields';\nDisplayCapabilities.KEY_MEDIA_CLOCK_FORMATS = 'mediaClockFormats';\nDisplayCapabilities.KEY_GRAPHIC_SUPPORTED = 'graphicSupported';\nDisplayCapabilities.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable';\nDisplayCapabilities.KEY_SCREEN_PARAMS = 'screenParams';\nDisplayCapabilities.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable';\n\nexport { DisplayCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Describes different sampling options for PerformAudioPassThru.\n * @typedef {Enum} SamplingRate\n * @property {Object} _MAP\n */\nclass SamplingRate extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Sampling rate of 8000 Hz.\n     * @return {String}\n     */\n    static get SamplingRate_8KHZ () {\n        return SamplingRate._MAP.SamplingRate_8KHZ;\n    }\n\n    /**\n     * Sampling rate of 16000 Hz.\n     * @return {String}\n     */\n    static get SamplingRate_16KHZ () {\n        return SamplingRate._MAP.SamplingRate_16KHZ;\n    }\n\n    /**\n     * Sampling rate of 22050 Hz.\n     * @return {String}\n     */\n    static get SamplingRate_22KHZ () {\n        return SamplingRate._MAP.SamplingRate_22KHZ;\n    }\n\n    /**\n     * Sampling rate of 44100 Hz.\n     * @return {String}\n     */\n    static get SamplingRate_44KHZ () {\n        return SamplingRate._MAP.SamplingRate_44KHZ;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SamplingRate._valueForKey(key, SamplingRate._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SamplingRate._keyForValue(value, SamplingRate._MAP);\n    }\n}\n\nSamplingRate._MAP = Object.freeze({\n    'SamplingRate_8KHZ': '8KHZ',\n    'SamplingRate_16KHZ': '16KHZ',\n    'SamplingRate_22KHZ': '22KHZ',\n    'SamplingRate_44KHZ': '44KHZ',\n});\n\nexport { SamplingRate };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Describes different quality options for PerformAudioPassThru.\n * @typedef {Enum} BitsPerSample\n * @property {Object} _MAP\n */\nclass BitsPerSample extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Audio sample is 8 bits wide, unsigned.\n     * @return {String}\n     */\n    static get BitsPerSample_8_BIT () {\n        return BitsPerSample._MAP.BitsPerSample_8_BIT;\n    }\n\n    /**\n     * Audio sample is 16 bits wide, signed, and in little endian.\n     * @return {String}\n     */\n    static get BitsPerSample_16_BIT () {\n        return BitsPerSample._MAP.BitsPerSample_16_BIT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return BitsPerSample._valueForKey(key, BitsPerSample._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return BitsPerSample._keyForValue(value, BitsPerSample._MAP);\n    }\n}\n\nBitsPerSample._MAP = Object.freeze({\n    'BitsPerSample_8_BIT': '8_BIT',\n    'BitsPerSample_16_BIT': '16_BIT',\n});\n\nexport { BitsPerSample };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Describes different audio type options for PerformAudioPassThru.\n * @typedef {Enum} AudioType\n * @property {Object} _MAP\n */\nclass AudioType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Linear PCM.\n     * @return {String}\n     */\n    static get PCM () {\n        return AudioType._MAP.PCM;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return AudioType._valueForKey(key, AudioType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return AudioType._keyForValue(value, AudioType._MAP);\n    }\n}\n\nAudioType._MAP = Object.freeze({\n    'PCM': 'PCM',\n});\n\nexport { AudioType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SamplingRate } from '../enums/SamplingRate.js';\nimport { BitsPerSample } from '../enums/BitsPerSample.js';\nimport { AudioType } from '../enums/AudioType.js';\n\n/**\n * Describes different audio type configurations for PerformAudioPassThru. e.g. {8kHz,8-bit,PCM} The audio is recorded\n * in monaural.\n */\nclass AudioPassThruCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {SamplingRate} rate - Describes different sampling options for PerformAudioPassThru.\n     * @return {AudioPassThruCapabilities}\n     */\n    setSamplingRate (rate) {\n        this.validateType(SamplingRate, rate);\n        this.setParameter(AudioPassThruCapabilities.KEY_SAMPLING_RATE, rate);\n        return this;\n    }\n\n    /**\n     * @return {SamplingRate}\n     */\n    getSamplingRate () {\n        return this.getObject(SamplingRate, AudioPassThruCapabilities.KEY_SAMPLING_RATE);\n    }\n\n    /**\n     * @param {BitsPerSample} sample - Describes different quality options for PerformAudioPassThru.\n     * @return {AudioPassThruCapabilities}\n     */\n    setBitsPerSample (sample) {\n        this.validateType(BitsPerSample, sample);\n        this.setParameter(AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE, sample);\n        return this;\n    }\n\n    /**\n     * @return {BitsPerSample}\n     */\n    getBitsPerSample () {\n        return this.getObject(BitsPerSample, AudioPassThruCapabilities.KEY_BITS_PER_SAMPLE);\n    }\n\n    /**\n     * @param {AudioType} type - Describes different audio type options for PerformAudioPassThru.\n     * @return {AudioPassThruCapabilities}\n     */\n    setAudioType (type) {\n        this.validateType(AudioType, type);\n        this.setParameter(AudioPassThruCapabilities.KEY_AUDIO_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {AudioType}\n     */\n    getAudioType () {\n        return this.getObject(AudioType, AudioPassThruCapabilities.KEY_AUDIO_TYPE);\n    }\n}\n\nAudioPassThruCapabilities.KEY_SAMPLING_RATE = 'samplingRate';\nAudioPassThruCapabilities.KEY_BITS_PER_SAMPLE = 'bitsPerSample';\nAudioPassThruCapabilities.KEY_AUDIO_TYPE = 'audioType';\n\nexport { AudioPassThruCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Contains information about the VR capabilities.\n * @typedef {Enum} VrCapabilities\n * @property {Object} _MAP\n */\nclass VrCapabilities extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VR_TEXT () {\n        return VrCapabilities._MAP.VR_TEXT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VrCapabilities._valueForKey(key, VrCapabilities._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VrCapabilities._keyForValue(value, VrCapabilities._MAP);\n    }\n}\n\nVrCapabilities._MAP = Object.freeze({\n    'VR_TEXT': 'TEXT',\n});\n\nexport { VrCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Defines the hard (physical) and soft (touchscreen) buttons available from the module\n * @typedef {Enum} ButtonName\n * @property {Object} _MAP\n */\nclass ButtonName extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OK () {\n        return ButtonName._MAP.OK;\n    }\n\n    /**\n     * The button name for the physical Play/Pause toggle that can be used by media apps.\n     * @return {String}\n     */\n    static get PLAY_PAUSE () {\n        return ButtonName._MAP.PLAY_PAUSE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEEKLEFT () {\n        return ButtonName._MAP.SEEKLEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEEKRIGHT () {\n        return ButtonName._MAP.SEEKRIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TUNEUP () {\n        return ButtonName._MAP.TUNEUP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TUNEDOWN () {\n        return ButtonName._MAP.TUNEDOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_0 () {\n        return ButtonName._MAP.PRESET_0;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_1 () {\n        return ButtonName._MAP.PRESET_1;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_2 () {\n        return ButtonName._MAP.PRESET_2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_3 () {\n        return ButtonName._MAP.PRESET_3;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_4 () {\n        return ButtonName._MAP.PRESET_4;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_5 () {\n        return ButtonName._MAP.PRESET_5;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_6 () {\n        return ButtonName._MAP.PRESET_6;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_7 () {\n        return ButtonName._MAP.PRESET_7;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_8 () {\n        return ButtonName._MAP.PRESET_8;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PRESET_9 () {\n        return ButtonName._MAP.PRESET_9;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CUSTOM_BUTTON () {\n        return ButtonName._MAP.CUSTOM_BUTTON;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEARCH () {\n        return ButtonName._MAP.SEARCH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AC_MAX () {\n        return ButtonName._MAP.AC_MAX;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AC () {\n        return ButtonName._MAP.AC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RECIRCULATE () {\n        return ButtonName._MAP.RECIRCULATE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FAN_UP () {\n        return ButtonName._MAP.FAN_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FAN_DOWN () {\n        return ButtonName._MAP.FAN_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TEMP_UP () {\n        return ButtonName._MAP.TEMP_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TEMP_DOWN () {\n        return ButtonName._MAP.TEMP_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFROST_MAX () {\n        return ButtonName._MAP.DEFROST_MAX;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFROST () {\n        return ButtonName._MAP.DEFROST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DEFROST_REAR () {\n        return ButtonName._MAP.DEFROST_REAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UPPER_VENT () {\n        return ButtonName._MAP.UPPER_VENT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LOWER_VENT () {\n        return ButtonName._MAP.LOWER_VENT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VOLUME_UP () {\n        return ButtonName._MAP.VOLUME_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VOLUME_DOWN () {\n        return ButtonName._MAP.VOLUME_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EJECT () {\n        return ButtonName._MAP.EJECT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SOURCE () {\n        return ButtonName._MAP.SOURCE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SHUFFLE () {\n        return ButtonName._MAP.SHUFFLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REPEAT () {\n        return ButtonName._MAP.REPEAT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_CENTER_LOCATION () {\n        return ButtonName._MAP.NAV_CENTER_LOCATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ZOOM_IN () {\n        return ButtonName._MAP.NAV_ZOOM_IN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ZOOM_OUT () {\n        return ButtonName._MAP.NAV_ZOOM_OUT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_UP () {\n        return ButtonName._MAP.NAV_PAN_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_UP_RIGHT () {\n        return ButtonName._MAP.NAV_PAN_UP_RIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_RIGHT () {\n        return ButtonName._MAP.NAV_PAN_RIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_DOWN_RIGHT () {\n        return ButtonName._MAP.NAV_PAN_DOWN_RIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_DOWN () {\n        return ButtonName._MAP.NAV_PAN_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_DOWN_LEFT () {\n        return ButtonName._MAP.NAV_PAN_DOWN_LEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_LEFT () {\n        return ButtonName._MAP.NAV_PAN_LEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_PAN_UP_LEFT () {\n        return ButtonName._MAP.NAV_PAN_UP_LEFT;\n    }\n\n    /**\n     * If supported, this toggles between a top-down view and an angled/3D view. If your app supports different, but\n     * substantially similar options, then you may implement those. If you don't implement these or similar options,\n     * do not subscribe to this button.\n     * @return {String}\n     */\n    static get NAV_TILT_TOGGLE () {\n        return ButtonName._MAP.NAV_TILT_TOGGLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ROTATE_CLOCKWISE () {\n        return ButtonName._MAP.NAV_ROTATE_CLOCKWISE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAV_ROTATE_COUNTERCLOCKWISE () {\n        return ButtonName._MAP.NAV_ROTATE_COUNTERCLOCKWISE;\n    }\n\n    /**\n     * If supported, this toggles between locking the orientation to north or to the vehicle's heading. If your app\n     * supports different, but substantially similar options, then you may implement those. If you don't implement\n     * these or similar options, do not subscribe to this button.\n     * @return {String}\n     */\n    static get NAV_HEADING_TOGGLE () {\n        return ButtonName._MAP.NAV_HEADING_TOGGLE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ButtonName._valueForKey(key, ButtonName._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ButtonName._keyForValue(value, ButtonName._MAP);\n    }\n}\n\nButtonName._MAP = Object.freeze({\n    'OK': 'OK',\n    'PLAY_PAUSE': 'PLAY_PAUSE',\n    'SEEKLEFT': 'SEEKLEFT',\n    'SEEKRIGHT': 'SEEKRIGHT',\n    'TUNEUP': 'TUNEUP',\n    'TUNEDOWN': 'TUNEDOWN',\n    'PRESET_0': 'PRESET_0',\n    'PRESET_1': 'PRESET_1',\n    'PRESET_2': 'PRESET_2',\n    'PRESET_3': 'PRESET_3',\n    'PRESET_4': 'PRESET_4',\n    'PRESET_5': 'PRESET_5',\n    'PRESET_6': 'PRESET_6',\n    'PRESET_7': 'PRESET_7',\n    'PRESET_8': 'PRESET_8',\n    'PRESET_9': 'PRESET_9',\n    'CUSTOM_BUTTON': 'CUSTOM_BUTTON',\n    'SEARCH': 'SEARCH',\n    'AC_MAX': 'AC_MAX',\n    'AC': 'AC',\n    'RECIRCULATE': 'RECIRCULATE',\n    'FAN_UP': 'FAN_UP',\n    'FAN_DOWN': 'FAN_DOWN',\n    'TEMP_UP': 'TEMP_UP',\n    'TEMP_DOWN': 'TEMP_DOWN',\n    'DEFROST_MAX': 'DEFROST_MAX',\n    'DEFROST': 'DEFROST',\n    'DEFROST_REAR': 'DEFROST_REAR',\n    'UPPER_VENT': 'UPPER_VENT',\n    'LOWER_VENT': 'LOWER_VENT',\n    'VOLUME_UP': 'VOLUME_UP',\n    'VOLUME_DOWN': 'VOLUME_DOWN',\n    'EJECT': 'EJECT',\n    'SOURCE': 'SOURCE',\n    'SHUFFLE': 'SHUFFLE',\n    'REPEAT': 'REPEAT',\n    'NAV_CENTER_LOCATION': 'NAV_CENTER_LOCATION',\n    'NAV_ZOOM_IN': 'NAV_ZOOM_IN',\n    'NAV_ZOOM_OUT': 'NAV_ZOOM_OUT',\n    'NAV_PAN_UP': 'NAV_PAN_UP',\n    'NAV_PAN_UP_RIGHT': 'NAV_PAN_UP_RIGHT',\n    'NAV_PAN_RIGHT': 'NAV_PAN_RIGHT',\n    'NAV_PAN_DOWN_RIGHT': 'NAV_PAN_DOWN_RIGHT',\n    'NAV_PAN_DOWN': 'NAV_PAN_DOWN',\n    'NAV_PAN_DOWN_LEFT': 'NAV_PAN_DOWN_LEFT',\n    'NAV_PAN_LEFT': 'NAV_PAN_LEFT',\n    'NAV_PAN_UP_LEFT': 'NAV_PAN_UP_LEFT',\n    'NAV_TILT_TOGGLE': 'NAV_TILT_TOGGLE',\n    'NAV_ROTATE_CLOCKWISE': 'NAV_ROTATE_CLOCKWISE',\n    'NAV_ROTATE_COUNTERCLOCKWISE': 'NAV_ROTATE_COUNTERCLOCKWISE',\n    'NAV_HEADING_TOGGLE': 'NAV_HEADING_TOGGLE',\n});\n\nexport { ButtonName };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Describes a location (origin coordinates and span) of a vehicle component.\n */\nclass Grid extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} col\n     * @return {Grid}\n     */\n    setColumn (col) {\n        this.setParameter(Grid.KEY_COLUMN, col);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getColumn () {\n        return this.getParameter(Grid.KEY_COLUMN);\n    }\n\n    /**\n     * @param {Number} row\n     * @return {Grid}\n     */\n    setRow (row) {\n        this.setParameter(Grid.KEY_ROW, row);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRow () {\n        return this.getParameter(Grid.KEY_ROW);\n    }\n\n    /**\n     * @param {Number} level\n     * @return {Grid}\n     */\n    setLevel (level) {\n        this.setParameter(Grid.KEY_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLevel () {\n        return this.getParameter(Grid.KEY_LEVEL);\n    }\n\n    /**\n     * @param {Number} colspan\n     * @return {Grid}\n     */\n    setColumnSpan (colspan) {\n        this.setParameter(Grid.KEY_COLUMN_SPAN, colspan);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getColumnSpan () {\n        return this.getParameter(Grid.KEY_COLUMN_SPAN);\n    }\n\n    /**\n     * @param {Number} rowspan\n     * @return {Grid}\n     */\n    setRowSpan (rowspan) {\n        this.setParameter(Grid.KEY_ROW_SPAN, rowspan);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRowSpan () {\n        return this.getParameter(Grid.KEY_ROW_SPAN);\n    }\n\n    /**\n     * @param {Number} levelspan\n     * @return {Grid}\n     */\n    setLevelSpan (levelspan) {\n        this.setParameter(Grid.KEY_LEVEL_SPAN, levelspan);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLevelSpan () {\n        return this.getParameter(Grid.KEY_LEVEL_SPAN);\n    }\n}\n\nGrid.KEY_COLUMN = 'col';\nGrid.KEY_ROW = 'row';\nGrid.KEY_LEVEL = 'level';\nGrid.KEY_COLUMN_SPAN = 'colspan';\nGrid.KEY_ROW_SPAN = 'rowspan';\nGrid.KEY_LEVEL_SPAN = 'levelspan';\n\nexport { Grid };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { Grid } from './Grid.js';\n\n/**\n * Information about a RC module\n */\nclass ModuleInfo extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} id - uuid of a module. \"moduleId + moduleType\" uniquely identify a module.\n     * @return {ModuleInfo}\n     */\n    setModuleId (id) {\n        this.setParameter(ModuleInfo.KEY_MODULE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleId () {\n        return this.getParameter(ModuleInfo.KEY_MODULE_ID);\n    }\n\n    /**\n     * @param {Grid} location - Location of a module.\n     * @return {ModuleInfo}\n     */\n    setLocation (location) {\n        this.validateType(Grid, location);\n        this.setParameter(ModuleInfo.KEY_LOCATION, location);\n        return this;\n    }\n\n    /**\n     * @return {Grid}\n     */\n    getLocation () {\n        return this.getObject(Grid, ModuleInfo.KEY_LOCATION);\n    }\n\n    /**\n     * @param {Grid} area - Service area of a module.\n     * @return {ModuleInfo}\n     */\n    setServiceArea (area) {\n        this.validateType(Grid, area);\n        this.setParameter(ModuleInfo.KEY_SERVICE_AREA, area);\n        return this;\n    }\n\n    /**\n     * @return {Grid}\n     */\n    getServiceArea () {\n        return this.getObject(Grid, ModuleInfo.KEY_SERVICE_AREA);\n    }\n\n    /**\n     * @param {Boolean} access - allow multiple users/apps to access the module or not\n     * @return {ModuleInfo}\n     */\n    setAllowMultipleAccess (access) {\n        this.setParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS, access);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAllowMultipleAccess () {\n        return this.getParameter(ModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS);\n    }\n}\n\nModuleInfo.KEY_MODULE_ID = 'moduleId';\nModuleInfo.KEY_LOCATION = 'location';\nModuleInfo.KEY_SERVICE_AREA = 'serviceArea';\nModuleInfo.KEY_ALLOW_MULTIPLE_ACCESS = 'allowMultipleAccess';\n\nexport { ModuleInfo };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ButtonName } from '../enums/ButtonName.js';\nimport { ModuleInfo } from './ModuleInfo.js';\n\n/**\n * Contains information about a button's capabilities.\n */\nclass ButtonCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ButtonName} name - The name of the button. See ButtonName.\n     * @return {ButtonCapabilities}\n     */\n    setName (name) {\n        this.validateType(ButtonName, name);\n        this.setParameter(ButtonCapabilities.KEY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {ButtonName}\n     */\n    getName () {\n        return this.getObject(ButtonName, ButtonCapabilities.KEY_NAME);\n    }\n\n    /**\n     * @param {ModuleInfo} info - Information about a RC module, including its id.\n     * @return {ButtonCapabilities}\n     */\n    setModuleInfo (info) {\n        this.validateType(ModuleInfo, info);\n        this.setParameter(ButtonCapabilities.KEY_MODULE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ModuleInfo}\n     */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, ButtonCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n     * @param {Boolean} available - The button supports a short press. Whenever the button is pressed short,\n     *                              onButtonPressed( SHORT) will be invoked.\n     * @return {ButtonCapabilities}\n     */\n    setShortPressAvailable (available) {\n        this.setParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getShortPressAvailable () {\n        return this.getParameter(ButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - The button supports a LONG press. Whenever the button is pressed long,\n     *                              onButtonPressed( LONG) will be invoked.\n     * @return {ButtonCapabilities}\n     */\n    setLongPressAvailable (available) {\n        this.setParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getLongPressAvailable () {\n        return this.getParameter(ButtonCapabilities.KEY_LONG_PRESS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - The button supports \"button down\" and \"button up\". Whenever the button is pressed,\n     *                              onButtonEvent( DOWN) will be invoked. Whenever the button is released,\n     *                              onButtonEvent( UP) will be invoked.\n     * @return {ButtonCapabilities}\n     */\n    setUpDownAvailable (available) {\n        this.setParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getUpDownAvailable () {\n        return this.getParameter(ButtonCapabilities.KEY_UP_DOWN_AVAILABLE);\n    }\n}\n\nButtonCapabilities.KEY_NAME = 'name';\nButtonCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nButtonCapabilities.KEY_SHORT_PRESS_AVAILABLE = 'shortPressAvailable';\nButtonCapabilities.KEY_LONG_PRESS_AVAILABLE = 'longPressAvailable';\nButtonCapabilities.KEY_UP_DOWN_AVAILABLE = 'upDownAvailable';\n\nexport { ButtonCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass HMICapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} navigation - Availability of build in Nav. True: Available, False: Not Available\n     * @return {HMICapabilities}\n     */\n    setNavigation (navigation) {\n        this.setParameter(HMICapabilities.KEY_NAVIGATION, navigation);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getNavigation () {\n        return this.getParameter(HMICapabilities.KEY_NAVIGATION);\n    }\n\n    /**\n     * @param {Boolean} call - Availability of build in phone. True: Available, False: Not Available\n     * @return {HMICapabilities}\n     */\n    setPhoneCall (call) {\n        this.setParameter(HMICapabilities.KEY_PHONE_CALL, call);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPhoneCall () {\n        return this.getParameter(HMICapabilities.KEY_PHONE_CALL);\n    }\n\n    /**\n     * @param {Boolean} streaming - Availability of video streaming.\n     * @return {HMICapabilities}\n     */\n    setVideoStreaming (streaming) {\n        this.setParameter(HMICapabilities.KEY_VIDEO_STREAMING, streaming);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getVideoStreaming () {\n        return this.getParameter(HMICapabilities.KEY_VIDEO_STREAMING);\n    }\n\n    /**\n     * @param {Boolean} control - Availability of remote control feature. True: Available, False: Not Available\n     * @return {HMICapabilities}\n     */\n    setRemoteControl (control) {\n        this.setParameter(HMICapabilities.KEY_REMOTE_CONTROL, control);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRemoteControl () {\n        return this.getParameter(HMICapabilities.KEY_REMOTE_CONTROL);\n    }\n\n    /**\n     * @param {Boolean} services - Availability of App Services functionality. True: Available, False: Not Available\n     * @return {HMICapabilities}\n     */\n    setAppServices (services) {\n        this.setParameter(HMICapabilities.KEY_APP_SERVICES, services);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAppServices () {\n        return this.getParameter(HMICapabilities.KEY_APP_SERVICES);\n    }\n\n    /**\n     * @param {Boolean} displays - Availability of displays capability. True: Available, False: Not Available\n     * @return {HMICapabilities}\n     */\n    setDisplays (displays) {\n        this.setParameter(HMICapabilities.KEY_DISPLAYS, displays);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDisplays () {\n        return this.getParameter(HMICapabilities.KEY_DISPLAYS);\n    }\n\n    /**\n     * @param {Boolean} location - Availability of seat location feature. True: Available, False: Not Available\n     * @return {HMICapabilities}\n     */\n    setSeatLocation (location) {\n        this.setParameter(HMICapabilities.KEY_SEAT_LOCATION, location);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSeatLocation () {\n        return this.getParameter(HMICapabilities.KEY_SEAT_LOCATION);\n    }\n}\n\nHMICapabilities.KEY_NAVIGATION = 'navigation';\nHMICapabilities.KEY_PHONE_CALL = 'phoneCall';\nHMICapabilities.KEY_VIDEO_STREAMING = 'videoStreaming';\nHMICapabilities.KEY_REMOTE_CONTROL = 'remoteControl';\nHMICapabilities.KEY_APP_SERVICES = 'appServices';\nHMICapabilities.KEY_DISPLAYS = 'displays';\nHMICapabilities.KEY_SEAT_LOCATION = 'seatLocation';\n\nexport { HMICapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SoftButtonCapabilities } from '../structs/SoftButtonCapabilities.js';\nimport { RpcResponse } from '../RpcResponse.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { SdlMsgVersion } from '../structs/SdlMsgVersion.js';\nimport { PrerecordedSpeech } from '../enums/PrerecordedSpeech.js';\nimport { SpeechCapabilities } from '../enums/SpeechCapabilities.js';\nimport { PresetBankCapabilities } from '../structs/PresetBankCapabilities.js';\nimport { VehicleType } from '../structs/VehicleType.js';\nimport { HmiZoneCapabilities } from '../enums/HmiZoneCapabilities.js';\nimport { DisplayCapabilities } from '../structs/DisplayCapabilities.js';\nimport { Language } from '../enums/Language.js';\nimport { AudioPassThruCapabilities } from '../structs/AudioPassThruCapabilities.js';\nimport { VrCapabilities } from '../enums/VrCapabilities.js';\nimport { ButtonCapabilities } from '../structs/ButtonCapabilities.js';\nimport { HMICapabilities } from '../structs/HMICapabilities.js';\n\n/**\n * The response to registerAppInterface\n */\nclass RegisterAppInterfaceResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.RegisterAppInterface);\n    }\n\n    /**\n     * @param {SdlMsgVersion} version - See SyncMsgVersion\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setSdlMsgVersion (version) {\n        this.validateType(SdlMsgVersion, version);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {SdlMsgVersion}\n     */\n    getSdlMsgVersion () {\n        return this.getObject(SdlMsgVersion, RegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION);\n    }\n\n    /**\n     * @param {Language} language - The currently active VR+TTS language on the module. See \"Language\" for options.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setLanguage (language) {\n        this.validateType(Language, language);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getLanguage () {\n        return this.getObject(Language, RegisterAppInterfaceResponse.KEY_LANGUAGE);\n    }\n\n    /**\n     * @param {Language} language - The currently active display language on the module. See \"Language\" for options.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setHmiDisplayLanguage (language) {\n        this.validateType(Language, language);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getHmiDisplayLanguage () {\n        return this.getObject(Language, RegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE);\n    }\n\n    /**\n     * @param {DisplayCapabilities} capabilities - See DisplayCapabilities. This parameter is deprecated and replaced by\n     *                                             SystemCapability using DISPLAYS.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setDisplayCapabilities (capabilities) {\n        this.validateType(DisplayCapabilities, capabilities);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {DisplayCapabilities}\n     */\n    getDisplayCapabilities () {\n        return this.getObject(DisplayCapabilities, RegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES);\n    }\n\n    /**\n     * @param {ButtonCapabilities[]} capabilities - See ButtonCapabilities. This parameter is deprecated and replaced by\n     *                                              SystemCapability using DISPLAYS.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setButtonCapabilities (capabilities) {\n        this.validateType(ButtonCapabilities, capabilities, true);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {ButtonCapabilities[]}\n     */\n    getButtonCapabilities () {\n        return this.getObject(ButtonCapabilities, RegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES);\n    }\n\n    /**\n     * @param {SoftButtonCapabilities[]} capabilities - If returned, the platform supports on-screen SoftButtons; see\n     *                                                  SoftButtonCapabilities. This parameter is deprecated and\n     *                                                  replaced by SystemCapability using DISPLAYS.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setSoftButtonCapabilities (capabilities) {\n        this.validateType(SoftButtonCapabilities, capabilities, true);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {SoftButtonCapabilities[]}\n     */\n    getSoftButtonCapabilities () {\n        return this.getObject(SoftButtonCapabilities, RegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES);\n    }\n\n    /**\n     * @param {PresetBankCapabilities} capabilities - If returned, the platform supports custom on-screen Presets; see\n     *                                                PresetBankCapabilities. This parameter is deprecated and replaced\n     *                                                by SystemCapability using DISPLAYS.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setPresetBankCapabilities (capabilities) {\n        this.validateType(PresetBankCapabilities, capabilities);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {PresetBankCapabilities}\n     */\n    getPresetBankCapabilities () {\n        return this.getObject(PresetBankCapabilities, RegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES);\n    }\n\n    /**\n     * @param {HmiZoneCapabilities[]} capabilities - See HmiZoneCapabilities\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setHmiZoneCapabilities (capabilities) {\n        this.validateType(HmiZoneCapabilities, capabilities, true);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {HmiZoneCapabilities[]}\n     */\n    getHmiZoneCapabilities () {\n        return this.getObject(HmiZoneCapabilities, RegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES);\n    }\n\n    /**\n     * @param {SpeechCapabilities[]} capabilities - See SpeechCapabilities\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setSpeechCapabilities (capabilities) {\n        this.validateType(SpeechCapabilities, capabilities, true);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {SpeechCapabilities[]}\n     */\n    getSpeechCapabilities () {\n        return this.getObject(SpeechCapabilities, RegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES);\n    }\n\n    /**\n     * @param {PrerecordedSpeech[]} speech - See PrerecordedSpeech\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setPrerecordedSpeech (speech) {\n        this.validateType(PrerecordedSpeech, speech, true);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH, speech);\n        return this;\n    }\n\n    /**\n     * @return {PrerecordedSpeech[]}\n     */\n    getPrerecordedSpeech () {\n        return this.getObject(PrerecordedSpeech, RegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH);\n    }\n\n    /**\n     * @param {VrCapabilities[]} capabilities - See VrCapabilities\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setVrCapabilities (capabilities) {\n        this.validateType(VrCapabilities, capabilities, true);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {VrCapabilities[]}\n     */\n    getVrCapabilities () {\n        return this.getObject(VrCapabilities, RegisterAppInterfaceResponse.KEY_VR_CAPABILITIES);\n    }\n\n    /**\n     * @param {AudioPassThruCapabilities[]} capabilities - See AudioPassThruCapability\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setAudioPassThruCapabilities (capabilities) {\n        this.validateType(AudioPassThruCapabilities, capabilities, true);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {AudioPassThruCapabilities[]}\n     */\n    getAudioPassThruCapabilities () {\n        return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES);\n    }\n\n    /**\n     * @param {AudioPassThruCapabilities} capabilities - See AudioPassThruCapability\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setPcmStreamCapabilities (capabilities) {\n        this.validateType(AudioPassThruCapabilities, capabilities);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {AudioPassThruCapabilities}\n     */\n    getPcmStreamCapabilities () {\n        return this.getObject(AudioPassThruCapabilities, RegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES);\n    }\n\n    /**\n     * @param {VehicleType} type - Specifies the vehicle's type. See VehicleType.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setVehicleType (type) {\n        this.validateType(VehicleType, type);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {VehicleType}\n     */\n    getVehicleType () {\n        return this.getObject(VehicleType, RegisterAppInterfaceResponse.KEY_VEHICLE_TYPE);\n    }\n\n    /**\n     * @param {Number[]} modes - Specifies the white-list of supported diagnostic modes (0x00-0xFF) capable for\n     *                           DiagnosticMessage requests. If a mode outside this list is requested, it will be\n     *                           rejected.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setSupportedDiagModes (modes) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES, modes);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getSupportedDiagModes () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES);\n    }\n\n    /**\n     * @param {HMICapabilities} capabilities - Specifies the HMI's capabilities. See HMICapabilities.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setHmiCapabilities (capabilities) {\n        this.validateType(HMICapabilities, capabilities);\n        this.setParameter(RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {HMICapabilities}\n     */\n    getHmiCapabilities () {\n        return this.getObject(HMICapabilities, RegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES);\n    }\n\n    /**\n     * @param {String} version - The SmartDeviceLink version.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setSdlVersion (version) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSdlVersion () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_SDL_VERSION);\n    }\n\n    /**\n     * @param {String} version - The software version of the system that implements the SmartDeviceLink core.\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setSystemSoftwareVersion (version) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSystemSoftwareVersion () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION);\n    }\n\n    /**\n     * @param {Boolean} resumed - Existence of apps icon at system. If true, apps icon was resumed at system. If false,\n     *                            apps icon is not resumed at system\n     * @return {RegisterAppInterfaceResponse}\n     */\n    setIconResumed (resumed) {\n        this.setParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED, resumed);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getIconResumed () {\n        return this.getParameter(RegisterAppInterfaceResponse.KEY_ICON_RESUMED);\n    }\n}\n\nRegisterAppInterfaceResponse.KEY_SDL_MSG_VERSION = 'syncMsgVersion';\nRegisterAppInterfaceResponse.KEY_LANGUAGE = 'language';\nRegisterAppInterfaceResponse.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage';\nRegisterAppInterfaceResponse.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities';\nRegisterAppInterfaceResponse.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities';\nRegisterAppInterfaceResponse.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities';\nRegisterAppInterfaceResponse.KEY_PRESET_BANK_CAPABILITIES = 'presetBankCapabilities';\nRegisterAppInterfaceResponse.KEY_HMI_ZONE_CAPABILITIES = 'hmiZoneCapabilities';\nRegisterAppInterfaceResponse.KEY_SPEECH_CAPABILITIES = 'speechCapabilities';\nRegisterAppInterfaceResponse.KEY_PRERECORDED_SPEECH = 'prerecordedSpeech';\nRegisterAppInterfaceResponse.KEY_VR_CAPABILITIES = 'vrCapabilities';\nRegisterAppInterfaceResponse.KEY_AUDIO_PASS_THRU_CAPABILITIES = 'audioPassThruCapabilities';\nRegisterAppInterfaceResponse.KEY_PCM_STREAM_CAPABILITIES = 'pcmStreamCapabilities';\nRegisterAppInterfaceResponse.KEY_VEHICLE_TYPE = 'vehicleType';\nRegisterAppInterfaceResponse.KEY_SUPPORTED_DIAG_MODES = 'supportedDiagModes';\nRegisterAppInterfaceResponse.KEY_HMI_CAPABILITIES = 'hmiCapabilities';\nRegisterAppInterfaceResponse.KEY_SDL_VERSION = 'sdlVersion';\nRegisterAppInterfaceResponse.KEY_SYSTEM_SOFTWARE_VERSION = 'systemSoftwareVersion';\nRegisterAppInterfaceResponse.KEY_ICON_RESUMED = 'iconResumed';\n\nexport { RegisterAppInterfaceResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Closes an interface from a mobile application. After unregisterAppInterface, no commands other than\n * registerAppInterface will be accepted/executed. Will fail, if no registerAppInterface was completed successfully\n * before.\n */\nclass UnregisterAppInterface extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnregisterAppInterface);\n    }\n}\n\n\nexport { UnregisterAppInterface };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass UnregisterAppInterfaceResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnregisterAppInterface);\n    }\n}\n\n\nexport { UnregisterAppInterfaceResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} WindowType\n * @property {Object} _MAP\n */\nclass WindowType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * This window type describes the main window on a display.\n     * @return {String}\n     */\n    static get MAIN () {\n        return WindowType._MAP.MAIN;\n    }\n\n    /**\n     * A widget is a small window that the app can create to provide information and soft buttons for quick app\n     * control.\n     * @return {String}\n     */\n    static get WIDGET () {\n        return WindowType._MAP.WIDGET;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return WindowType._valueForKey(key, WindowType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return WindowType._keyForValue(value, WindowType._MAP);\n    }\n}\n\nWindowType._MAP = Object.freeze({\n    'MAIN': 'MAIN',\n    'WIDGET': 'WIDGET',\n});\n\nexport { WindowType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { WindowType } from '../enums/WindowType.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Create a new window on the display with the specified window type.\n */\nclass CreateWindow extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CreateWindow);\n    }\n\n    /**\n     * @param {Number} id - A unique ID to identify the window. The value of '0' will always be the default main window\n     *                      on the main display and should not be used in this context as it will already be created for\n     *                      the app. See PredefinedWindows enum. Creating a window with an ID that is already in use\n     *                      will be rejected with `INVALID_ID`.\n     * @return {CreateWindow}\n     */\n    setWindowID (id) {\n        this.setParameter(CreateWindow.KEY_WINDOW_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindowID () {\n        return this.getParameter(CreateWindow.KEY_WINDOW_ID);\n    }\n\n    /**\n     * @param {String} name - The window name to be used by the HMI. The name of the pre-created default window will\n     *                        match the app name. Multiple apps can share the same window name except for the default\n     *                        main window. Creating a window with a name which is already in use by the app will result\n     *                        in `DUPLICATE_NAME`.\n     * @return {CreateWindow}\n     */\n    setWindowName (name) {\n        this.setParameter(CreateWindow.KEY_WINDOW_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getWindowName () {\n        return this.getParameter(CreateWindow.KEY_WINDOW_NAME);\n    }\n\n    /**\n     * @param {WindowType} type - The type of the window to be created. Main window or widget.\n     * @return {CreateWindow}\n     */\n    setType (type) {\n        this.validateType(WindowType, type);\n        this.setParameter(CreateWindow.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {WindowType}\n     */\n    getType () {\n        return this.getObject(WindowType, CreateWindow.KEY_TYPE);\n    }\n\n    /**\n     * @param {String} type - Allows an app to create a widget related to a specific service type. As an example if a\n     *                        `MEDIA` app becomes active, this app becomes audible and is allowed to play audio. Actions\n     *                        such as skip or play/pause will be directed to this active media app. In case of widgets,\n     *                        the system can provide a single \"media\" widget which will act as a placeholder for the\n     *                        active media app. It is only allowed to have one window per service type. This means that\n     *                        a media app can only have a single MEDIA widget. Still the app can create widgets omitting\n     *                        this parameter. Those widgets would be available as app specific widgets that are\n     *                        permanently included in the HMI. This parameter is related to widgets only. The default\n     *                        main window, which is pre-created during app registration, will be created based on the\n     *                        HMI types specified in the app registration request.\n     * @return {CreateWindow}\n     */\n    setAssociatedServiceType (type) {\n        this.setParameter(CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAssociatedServiceType () {\n        return this.getParameter(CreateWindow.KEY_ASSOCIATED_SERVICE_TYPE);\n    }\n\n    /**\n     * @param {Number} id - Optional parameter. Specify whether the content sent to an existing window should be\n     *                      duplicated to the created window. If there isn't a window with the ID, the request will be\n     *                      rejected with `INVALID_DATA`.\n     * @return {CreateWindow}\n     */\n    setDuplicateUpdatesFromWindowID (id) {\n        this.setParameter(CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDuplicateUpdatesFromWindowID () {\n        return this.getParameter(CreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID);\n    }\n}\n\nCreateWindow.KEY_WINDOW_ID = 'windowID';\nCreateWindow.KEY_WINDOW_NAME = 'windowName';\nCreateWindow.KEY_TYPE = 'type';\nCreateWindow.KEY_ASSOCIATED_SERVICE_TYPE = 'associatedServiceType';\nCreateWindow.KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID = 'duplicateUpdatesFromWindowID';\n\nexport { CreateWindow };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass CreateWindowResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CreateWindow);\n    }\n}\n\n\nexport { CreateWindowResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Deletes previously created window of the SDL application.\n */\nclass DeleteWindow extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteWindow);\n    }\n\n    /**\n     * @param {Number} id - A unique ID to identify the window. The value of '0' will always be the default main window\n     *                      on the main display and cannot be deleted. See PredefinedWindows enum.\n     * @return {DeleteWindow}\n     */\n    setWindowID (id) {\n        this.setParameter(DeleteWindow.KEY_WINDOW_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindowID () {\n        return this.getParameter(DeleteWindow.KEY_WINDOW_ID);\n    }\n}\n\nDeleteWindow.KEY_WINDOW_ID = 'windowID';\n\nexport { DeleteWindow };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass DeleteWindowResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteWindow);\n    }\n}\n\n\nexport { DeleteWindowResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Contains information about the type of image.\n * @typedef {Enum} ImageType\n * @property {Object} _MAP\n */\nclass ImageType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get STATIC () {\n        return ImageType._MAP.STATIC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DYNAMIC () {\n        return ImageType._MAP.DYNAMIC;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ImageType._valueForKey(key, ImageType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ImageType._keyForValue(value, ImageType._MAP);\n    }\n}\n\nImageType._MAP = Object.freeze({\n    'STATIC': 'STATIC',\n    'DYNAMIC': 'DYNAMIC',\n});\n\nexport { ImageType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ImageType } from '../enums/ImageType.js';\n\nclass Image extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} value - Either the static hex icon value or the binary image file name identifier (sent by\n     *                         PutFile).\n     * @return {Image}\n     */\n    setValue (value) {\n        this.setParameter(Image.KEY_VALUE, value);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getValue () {\n        return this.getParameter(Image.KEY_VALUE);\n    }\n\n    /**\n     * @param {ImageType} type - Describes, whether it is a static or dynamic image.\n     * @return {Image}\n     */\n    setImageType (type) {\n        this.validateType(ImageType, type);\n        this.setParameter(Image.KEY_IMAGE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {ImageType}\n     */\n    getImageType () {\n        return this.getObject(ImageType, Image.KEY_IMAGE_TYPE);\n    }\n\n    /**\n     * @param {Boolean} template - If true, the image is a template image and can be recolored by the HMI\n     * @return {Image}\n     */\n    setIsTemplate (template) {\n        this.setParameter(Image.KEY_IS_TEMPLATE, template);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getIsTemplate () {\n        return this.getParameter(Image.KEY_IS_TEMPLATE);\n    }\n}\n\nImage.KEY_VALUE = 'value';\nImage.KEY_IMAGE_TYPE = 'imageType';\nImage.KEY_IS_TEMPLATE = 'isTemplate';\n\nexport { Image };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { Image } from './Image.js';\n\nclass VrHelpItem extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} text - Text to display for VR Help item\n     * @return {VrHelpItem}\n     */\n    setText (text) {\n        this.setParameter(VrHelpItem.KEY_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getText () {\n        return this.getParameter(VrHelpItem.KEY_TEXT);\n    }\n\n    /**\n     * @param {Image} image - Image struct for VR Help item\n     * @return {VrHelpItem}\n     */\n    setImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(VrHelpItem.KEY_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getImage () {\n        return this.getObject(Image, VrHelpItem.KEY_IMAGE);\n    }\n\n    /**\n     * @param {Number} position - Position to display item in VR Help list\n     * @return {VrHelpItem}\n     */\n    setPosition (position) {\n        this.setParameter(VrHelpItem.KEY_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPosition () {\n        return this.getParameter(VrHelpItem.KEY_POSITION);\n    }\n}\n\nVrHelpItem.KEY_TEXT = 'text';\nVrHelpItem.KEY_IMAGE = 'image';\nVrHelpItem.KEY_POSITION = 'position';\n\nexport { VrHelpItem };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { Grid } from './Grid.js';\n\n/**\n * Describes the location of a seat.\n */\nclass SeatLocation extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Grid} grid - Describes a location (origin coordinates and span) of a vehicle component.\n     * @return {SeatLocation}\n     */\n    setGrid (grid) {\n        this.validateType(Grid, grid);\n        this.setParameter(SeatLocation.KEY_GRID, grid);\n        return this;\n    }\n\n    /**\n     * @return {Grid}\n     */\n    getGrid () {\n        return this.getObject(Grid, SeatLocation.KEY_GRID);\n    }\n}\n\nSeatLocation.KEY_GRID = 'grid';\n\nexport { SeatLocation };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * How the main menu or submenu is laid out on screen\n * @typedef {Enum} MenuLayout\n * @property {Object} _MAP\n */\nclass MenuLayout extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LIST () {\n        return MenuLayout._MAP.LIST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TILES () {\n        return MenuLayout._MAP.TILES;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MenuLayout._valueForKey(key, MenuLayout._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MenuLayout._keyForValue(value, MenuLayout._MAP);\n    }\n}\n\nMenuLayout._MAP = Object.freeze({\n    'LIST': 'LIST',\n    'TILES': 'TILES',\n});\n\nexport { MenuLayout };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration listing possible keyboard layouts.\n * @typedef {Enum} KeyboardLayout\n * @property {Object} _MAP\n */\nclass KeyboardLayout extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get QWERTY () {\n        return KeyboardLayout._MAP.QWERTY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get QWERTZ () {\n        return KeyboardLayout._MAP.QWERTZ;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AZERTY () {\n        return KeyboardLayout._MAP.AZERTY;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return KeyboardLayout._valueForKey(key, KeyboardLayout._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return KeyboardLayout._keyForValue(value, KeyboardLayout._MAP);\n    }\n}\n\nKeyboardLayout._MAP = Object.freeze({\n    'QWERTY': 'QWERTY',\n    'QWERTZ': 'QWERTZ',\n    'AZERTY': 'AZERTY',\n});\n\nexport { KeyboardLayout };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration listing possible keyboard events.\n * @typedef {Enum} KeypressMode\n * @property {Object} _MAP\n */\nclass KeypressMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Each keypress is individually sent as the user presses the keyboard keys.\n     * @return {String}\n     */\n    static get SINGLE_KEYPRESS () {\n        return KeypressMode._MAP.SINGLE_KEYPRESS;\n    }\n\n    /**\n     * The keypresses are queued and a string is eventually sent once the user chooses to submit their entry.\n     * @return {String}\n     */\n    static get QUEUE_KEYPRESSES () {\n        return KeypressMode._MAP.QUEUE_KEYPRESSES;\n    }\n\n    /**\n     * The keypresses are queue and a string is sent each time the user presses a keyboard key; the string contains\n     * the entire current entry.\n     * @return {String}\n     */\n    static get RESEND_CURRENT_ENTRY () {\n        return KeypressMode._MAP.RESEND_CURRENT_ENTRY;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return KeypressMode._valueForKey(key, KeypressMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return KeypressMode._keyForValue(value, KeypressMode._MAP);\n    }\n}\n\nKeypressMode._MAP = Object.freeze({\n    'SINGLE_KEYPRESS': 'SINGLE_KEYPRESS',\n    'QUEUE_KEYPRESSES': 'QUEUE_KEYPRESSES',\n    'RESEND_CURRENT_ENTRY': 'RESEND_CURRENT_ENTRY',\n});\n\nexport { KeypressMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { KeyboardLayout } from '../enums/KeyboardLayout.js';\nimport { Language } from '../enums/Language.js';\nimport { KeypressMode } from '../enums/KeypressMode.js';\n\n/**\n * Configuration of on-screen keyboard (if available).\n */\nclass KeyboardProperties extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Language} language - The keyboard language.\n     * @return {KeyboardProperties}\n     */\n    setLanguage (language) {\n        this.validateType(Language, language);\n        this.setParameter(KeyboardProperties.KEY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getLanguage () {\n        return this.getObject(Language, KeyboardProperties.KEY_LANGUAGE);\n    }\n\n    /**\n     * @param {KeyboardLayout} layout - Desired keyboard layout.\n     * @return {KeyboardProperties}\n     */\n    setKeyboardLayout (layout) {\n        this.validateType(KeyboardLayout, layout);\n        this.setParameter(KeyboardProperties.KEY_KEYBOARD_LAYOUT, layout);\n        return this;\n    }\n\n    /**\n     * @return {KeyboardLayout}\n     */\n    getKeyboardLayout () {\n        return this.getObject(KeyboardLayout, KeyboardProperties.KEY_KEYBOARD_LAYOUT);\n    }\n\n    /**\n     * @param {KeypressMode} mode - Desired keypress mode. If omitted, this value will be set to RESEND_CURRENT_ENTRY.\n     * @return {KeyboardProperties}\n     */\n    setKeypressMode (mode) {\n        this.validateType(KeypressMode, mode);\n        this.setParameter(KeyboardProperties.KEY_KEYPRESS_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {KeypressMode}\n     */\n    getKeypressMode () {\n        return this.getObject(KeypressMode, KeyboardProperties.KEY_KEYPRESS_MODE);\n    }\n\n    /**\n     * @param {String[]} list - Array of keyboard characters to enable. All omitted characters will be greyed out\n     *                          (disabled) on the keyboard. If omitted, the entire keyboard will be enabled.\n     * @return {KeyboardProperties}\n     */\n    setLimitedCharacterList (list) {\n        this.setParameter(KeyboardProperties.KEY_LIMITED_CHARACTER_LIST, list);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getLimitedCharacterList () {\n        return this.getParameter(KeyboardProperties.KEY_LIMITED_CHARACTER_LIST);\n    }\n\n    /**\n     * @param {String} text - Deprecated, use autoCompleteList instead.\n     * @return {KeyboardProperties}\n     */\n    setAutoCompleteText (text) {\n        this.setParameter(KeyboardProperties.KEY_AUTO_COMPLETE_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAutoCompleteText () {\n        return this.getParameter(KeyboardProperties.KEY_AUTO_COMPLETE_TEXT);\n    }\n\n    /**\n     * @param {String[]} list - Allows an app to prepopulate the text field with a list of suggested or completed\n     *                          entries as the user types. If empty, the auto-complete list will be removed from the\n     *                          screen.\n     * @return {KeyboardProperties}\n     */\n    setAutoCompleteList (list) {\n        this.setParameter(KeyboardProperties.KEY_AUTO_COMPLETE_LIST, list);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getAutoCompleteList () {\n        return this.getParameter(KeyboardProperties.KEY_AUTO_COMPLETE_LIST);\n    }\n}\n\nKeyboardProperties.KEY_LANGUAGE = 'language';\nKeyboardProperties.KEY_KEYBOARD_LAYOUT = 'keyboardLayout';\nKeyboardProperties.KEY_KEYPRESS_MODE = 'keypressMode';\nKeyboardProperties.KEY_LIMITED_CHARACTER_LIST = 'limitedCharacterList';\nKeyboardProperties.KEY_AUTO_COMPLETE_TEXT = 'autoCompleteText';\nKeyboardProperties.KEY_AUTO_COMPLETE_LIST = 'autoCompleteList';\n\nexport { KeyboardProperties };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { VrHelpItem } from '../structs/VrHelpItem.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { SeatLocation } from '../structs/SeatLocation.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { MenuLayout } from '../enums/MenuLayout.js';\nimport { KeyboardProperties } from '../structs/KeyboardProperties.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { Image } from '../structs/Image.js';\n\n/**\n * Allows setting global properties.\n */\nclass SetGlobalProperties extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetGlobalProperties);\n    }\n\n    /**\n     * @param {SeatLocation} location - Location of the user's seat. Default is driver's seat location if it is not set\n     *                                  yet.\n     * @return {SetGlobalProperties}\n     */\n    setUserLocation (location) {\n        this.validateType(SeatLocation, location);\n        this.setParameter(SetGlobalProperties.KEY_USER_LOCATION, location);\n        return this;\n    }\n\n    /**\n     * @return {SeatLocation}\n     */\n    getUserLocation () {\n        return this.getObject(SeatLocation, SetGlobalProperties.KEY_USER_LOCATION);\n    }\n\n    /**\n     * @param {TTSChunk[]} prompt - The help prompt. An array of text chunks of type TTSChunk. See TTSChunk. The array\n     *                              must have at least one item.\n     * @return {SetGlobalProperties}\n     */\n    setHelpPrompt (prompt) {\n        this.validateType(TTSChunk, prompt, true);\n        this.setParameter(SetGlobalProperties.KEY_HELP_PROMPT, prompt);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getHelpPrompt () {\n        return this.getObject(TTSChunk, SetGlobalProperties.KEY_HELP_PROMPT);\n    }\n\n    /**\n     * @param {TTSChunk[]} prompt - Help text for a wait timeout. An array of text chunks of type TTSChunk. See\n     *                              TTSChunk. The array must have at least one item.\n     * @return {SetGlobalProperties}\n     */\n    setTimeoutPrompt (prompt) {\n        this.validateType(TTSChunk, prompt, true);\n        this.setParameter(SetGlobalProperties.KEY_TIMEOUT_PROMPT, prompt);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getTimeoutPrompt () {\n        return this.getObject(TTSChunk, SetGlobalProperties.KEY_TIMEOUT_PROMPT);\n    }\n\n    /**\n     * @param {String} title - VR Help Title text. If omitted on supported displays, the default module help title shall\n     *                         be used. If omitted and one or more vrHelp items are provided, the request will be\n     *                         rejected.\n     * @return {SetGlobalProperties}\n     */\n    setVrHelpTitle (title) {\n        this.setParameter(SetGlobalProperties.KEY_VR_HELP_TITLE, title);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getVrHelpTitle () {\n        return this.getParameter(SetGlobalProperties.KEY_VR_HELP_TITLE);\n    }\n\n    /**\n     * @param {VrHelpItem[]} help - VR Help Items. If omitted on supported displays, the default SmartDeviceLink VR help\n     *                              / What Can I Say? screen shall be used. If the list of VR Help Items contains\n     *                              nonsequential positions (e.g. [1,2,4]), the RPC shall be rejected. If omitted and a\n     *                              vrHelpTitle is provided, the request will be rejected.\n     * @return {SetGlobalProperties}\n     */\n    setVrHelp (help) {\n        this.validateType(VrHelpItem, help, true);\n        this.setParameter(SetGlobalProperties.KEY_VR_HELP, help);\n        return this;\n    }\n\n    /**\n     * @return {VrHelpItem[]}\n     */\n    getVrHelp () {\n        return this.getObject(VrHelpItem, SetGlobalProperties.KEY_VR_HELP);\n    }\n\n    /**\n     * @param {String} title - Optional text to label an app menu button (for certain touchscreen platforms).\n     * @return {SetGlobalProperties}\n     */\n    setMenuTitle (title) {\n        this.setParameter(SetGlobalProperties.KEY_MENU_TITLE, title);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMenuTitle () {\n        return this.getParameter(SetGlobalProperties.KEY_MENU_TITLE);\n    }\n\n    /**\n     * @param {Image} icon - Optional icon to draw on an app menu button (for certain touchscreen platforms).\n     * @return {SetGlobalProperties}\n     */\n    setMenuIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(SetGlobalProperties.KEY_MENU_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getMenuIcon () {\n        return this.getObject(Image, SetGlobalProperties.KEY_MENU_ICON);\n    }\n\n    /**\n     * @param {KeyboardProperties} properties - On-screen keyboard configuration (if available).\n     * @return {SetGlobalProperties}\n     */\n    setKeyboardProperties (properties) {\n        this.validateType(KeyboardProperties, properties);\n        this.setParameter(SetGlobalProperties.KEY_KEYBOARD_PROPERTIES, properties);\n        return this;\n    }\n\n    /**\n     * @return {KeyboardProperties}\n     */\n    getKeyboardProperties () {\n        return this.getObject(KeyboardProperties, SetGlobalProperties.KEY_KEYBOARD_PROPERTIES);\n    }\n\n    /**\n     * @param {MenuLayout} layout - Sets the layout of the main menu screen. If this is sent while a menu is already on-\n     *                              screen, the head unit will change the display to the new layout type.\n     * @return {SetGlobalProperties}\n     */\n    setMenuLayout (layout) {\n        this.validateType(MenuLayout, layout);\n        this.setParameter(SetGlobalProperties.KEY_MENU_LAYOUT, layout);\n        return this;\n    }\n\n    /**\n     * @return {MenuLayout}\n     */\n    getMenuLayout () {\n        return this.getObject(MenuLayout, SetGlobalProperties.KEY_MENU_LAYOUT);\n    }\n}\n\nSetGlobalProperties.KEY_USER_LOCATION = 'userLocation';\nSetGlobalProperties.KEY_HELP_PROMPT = 'helpPrompt';\nSetGlobalProperties.KEY_TIMEOUT_PROMPT = 'timeoutPrompt';\nSetGlobalProperties.KEY_VR_HELP_TITLE = 'vrHelpTitle';\nSetGlobalProperties.KEY_VR_HELP = 'vrHelp';\nSetGlobalProperties.KEY_MENU_TITLE = 'menuTitle';\nSetGlobalProperties.KEY_MENU_ICON = 'menuIcon';\nSetGlobalProperties.KEY_KEYBOARD_PROPERTIES = 'keyboardProperties';\nSetGlobalProperties.KEY_MENU_LAYOUT = 'menuLayout';\n\nexport { SetGlobalProperties };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SetGlobalPropertiesResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetGlobalProperties);\n    }\n}\n\n\nexport { SetGlobalPropertiesResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The different global properties.\n * @typedef {Enum} GlobalProperty\n * @property {Object} _MAP\n */\nclass GlobalProperty extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Location of the user's seat of setGlobalProperties\n     * @return {String}\n     */\n    static get USER_LOCATION () {\n        return GlobalProperty._MAP.USER_LOCATION;\n    }\n\n    /**\n     * The property helpPrompt of setGlobalProperties\n     * @return {String}\n     */\n    static get HELPPROMPT () {\n        return GlobalProperty._MAP.HELPPROMPT;\n    }\n\n    /**\n     * The property timeoutPrompt of setGlobalProperties\n     * @return {String}\n     */\n    static get TIMEOUTPROMPT () {\n        return GlobalProperty._MAP.TIMEOUTPROMPT;\n    }\n\n    /**\n     * The property vrHelpTitle of setGlobalProperties\n     * @return {String}\n     */\n    static get VRHELPTITLE () {\n        return GlobalProperty._MAP.VRHELPTITLE;\n    }\n\n    /**\n     * The property array of vrHelp of setGlobalProperties\n     * @return {String}\n     */\n    static get VRHELPITEMS () {\n        return GlobalProperty._MAP.VRHELPITEMS;\n    }\n\n    /**\n     * The property in-app menu name of setGlobalProperties\n     * @return {String}\n     */\n    static get MENUNAME () {\n        return GlobalProperty._MAP.MENUNAME;\n    }\n\n    /**\n     * The property in-app menu icon of setGlobalProperties\n     * @return {String}\n     */\n    static get MENUICON () {\n        return GlobalProperty._MAP.MENUICON;\n    }\n\n    /**\n     * The on-screen keyboard configuration of setGlobalProperties\n     * @return {String}\n     */\n    static get KEYBOARDPROPERTIES () {\n        return GlobalProperty._MAP.KEYBOARDPROPERTIES;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return GlobalProperty._valueForKey(key, GlobalProperty._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return GlobalProperty._keyForValue(value, GlobalProperty._MAP);\n    }\n}\n\nGlobalProperty._MAP = Object.freeze({\n    'USER_LOCATION': 'USER_LOCATION',\n    'HELPPROMPT': 'HELPPROMPT',\n    'TIMEOUTPROMPT': 'TIMEOUTPROMPT',\n    'VRHELPTITLE': 'VRHELPTITLE',\n    'VRHELPITEMS': 'VRHELPITEMS',\n    'MENUNAME': 'MENUNAME',\n    'MENUICON': 'MENUICON',\n    'KEYBOARDPROPERTIES': 'KEYBOARDPROPERTIES',\n});\n\nexport { GlobalProperty };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { GlobalProperty } from '../enums/GlobalProperty.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Allows resetting global properties.\n */\nclass ResetGlobalProperties extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ResetGlobalProperties);\n    }\n\n    /**\n     * @param {GlobalProperty[]} properties - Contains the names of all global properties (like timeoutPrompt) that\n     *                                        should be unset. Resetting means, that they have the same value as at\n     *                                        start up (default)\n     * @return {ResetGlobalProperties}\n     */\n    setProperties (properties) {\n        this.validateType(GlobalProperty, properties, true);\n        this.setParameter(ResetGlobalProperties.KEY_PROPERTIES, properties);\n        return this;\n    }\n\n    /**\n     * @return {GlobalProperty[]}\n     */\n    getProperties () {\n        return this.getObject(GlobalProperty, ResetGlobalProperties.KEY_PROPERTIES);\n    }\n}\n\nResetGlobalProperties.KEY_PROPERTIES = 'properties';\n\nexport { ResetGlobalProperties };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ResetGlobalPropertiesResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ResetGlobalProperties);\n    }\n}\n\n\nexport { ResetGlobalPropertiesResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass MenuParams extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} id - unique ID of the sub menu, the command will be added to. If not provided, it will be\n     *                      provided to the top level of the in application menu.\n     * @return {MenuParams}\n     */\n    setParentID (id) {\n        this.setParameter(MenuParams.KEY_PARENT_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getParentID () {\n        return this.getParameter(MenuParams.KEY_PARENT_ID);\n    }\n\n    /**\n     * @param {Number} position - Position within the items that are are at top level of the in application menu. 0 will\n     *                            insert at the front. 1 will insert at the second position. if position is greater or\n     *                            equal than the number of items on top level, the sub menu will be appended to the end.\n     *                            If this param was omitted the entry will be added at the end.\n     * @return {MenuParams}\n     */\n    setPosition (position) {\n        this.setParameter(MenuParams.KEY_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPosition () {\n        return this.getParameter(MenuParams.KEY_POSITION);\n    }\n\n    /**\n     * @param {String} name - Text to show in the menu for this sub menu.\n     * @return {MenuParams}\n     */\n    setMenuName (name) {\n        this.setParameter(MenuParams.KEY_MENU_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMenuName () {\n        return this.getParameter(MenuParams.KEY_MENU_NAME);\n    }\n}\n\nMenuParams.KEY_PARENT_ID = 'parentID';\nMenuParams.KEY_POSITION = 'position';\nMenuParams.KEY_MENU_NAME = 'menuName';\n\nexport { MenuParams };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { MenuParams } from '../structs/MenuParams.js';\nimport { Image } from '../structs/Image.js';\n\n/**\n * Adds a command to the in application menu. Either menuParams or vrCommands must be provided.\n */\nclass AddCommand extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AddCommand);\n    }\n\n    /**\n     * @param {Number} id - unique ID of the command to add.\n     * @return {AddCommand}\n     */\n    setCmdID (id) {\n        this.setParameter(AddCommand.KEY_CMD_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCmdID () {\n        return this.getParameter(AddCommand.KEY_CMD_ID);\n    }\n\n    /**\n     * @param {MenuParams} params - Optional sub value containing menu parameters\n     * @return {AddCommand}\n     */\n    setMenuParams (params) {\n        this.validateType(MenuParams, params);\n        this.setParameter(AddCommand.KEY_MENU_PARAMS, params);\n        return this;\n    }\n\n    /**\n     * @return {MenuParams}\n     */\n    getMenuParams () {\n        return this.getObject(MenuParams, AddCommand.KEY_MENU_PARAMS);\n    }\n\n    /**\n     * @param {String[]} commands - An array of strings to be used as VR synonyms for this command. If this array is\n     *                              provided, it may not be empty.\n     * @return {AddCommand}\n     */\n    setVrCommands (commands) {\n        this.setParameter(AddCommand.KEY_VR_COMMANDS, commands);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getVrCommands () {\n        return this.getParameter(AddCommand.KEY_VR_COMMANDS);\n    }\n\n    /**\n     * @param {Image} icon - Image struct determining whether static or dynamic icon. If omitted on supported displays,\n     *                       no (or the default if applicable) icon shall be displayed.\n     * @return {AddCommand}\n     */\n    setCmdIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(AddCommand.KEY_CMD_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getCmdIcon () {\n        return this.getObject(Image, AddCommand.KEY_CMD_ICON);\n    }\n}\n\nAddCommand.KEY_CMD_ID = 'cmdID';\nAddCommand.KEY_MENU_PARAMS = 'menuParams';\nAddCommand.KEY_VR_COMMANDS = 'vrCommands';\nAddCommand.KEY_CMD_ICON = 'cmdIcon';\n\nexport { AddCommand };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass AddCommandResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AddCommand);\n    }\n}\n\n\nexport { AddCommandResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Deletes all commands from the in-application menu with the specified command id.\n */\nclass DeleteCommand extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteCommand);\n    }\n\n    /**\n     * @param {Number} id - ID of the command(s) to delete.\n     * @return {DeleteCommand}\n     */\n    setCmdID (id) {\n        this.setParameter(DeleteCommand.KEY_CMD_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCmdID () {\n        return this.getParameter(DeleteCommand.KEY_CMD_ID);\n    }\n}\n\nDeleteCommand.KEY_CMD_ID = 'cmdID';\n\nexport { DeleteCommand };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass DeleteCommandResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteCommand);\n    }\n}\n\n\nexport { DeleteCommandResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { MenuLayout } from '../enums/MenuLayout.js';\nimport { Image } from '../structs/Image.js';\n\n/**\n * Adds a sub menu to the in-application menu.\n */\nclass AddSubMenu extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AddSubMenu);\n    }\n\n    /**\n     * @param {Number} id - unique ID of the sub menu to add.\n     * @return {AddSubMenu}\n     */\n    setMenuID (id) {\n        this.setParameter(AddSubMenu.KEY_MENU_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMenuID () {\n        return this.getParameter(AddSubMenu.KEY_MENU_ID);\n    }\n\n    /**\n     * @param {Number} position - Position within the items that are are at top level of the in application menu. 0 will\n     *                            insert at the front. 1 will insert at the second position. If position is greater or\n     *                            equal than the number of items on top level, the sub menu will be appended to the end.\n     *                            Position of any submenu will always be located before the return and exit options If\n     *                            this param was omitted the entry will be added at the end.\n     * @return {AddSubMenu}\n     */\n    setPosition (position) {\n        this.setParameter(AddSubMenu.KEY_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPosition () {\n        return this.getParameter(AddSubMenu.KEY_POSITION);\n    }\n\n    /**\n     * @param {String} name - Text to show in the menu for this sub menu.\n     * @return {AddSubMenu}\n     */\n    setMenuName (name) {\n        this.setParameter(AddSubMenu.KEY_MENU_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMenuName () {\n        return this.getParameter(AddSubMenu.KEY_MENU_NAME);\n    }\n\n    /**\n     * @param {Image} icon - The image field for AddSubMenu\n     * @return {AddSubMenu}\n     */\n    setMenuIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(AddSubMenu.KEY_MENU_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getMenuIcon () {\n        return this.getObject(Image, AddSubMenu.KEY_MENU_ICON);\n    }\n\n    /**\n     * @param {MenuLayout} layout - Sets the layout of the submenu screen.\n     * @return {AddSubMenu}\n     */\n    setMenuLayout (layout) {\n        this.validateType(MenuLayout, layout);\n        this.setParameter(AddSubMenu.KEY_MENU_LAYOUT, layout);\n        return this;\n    }\n\n    /**\n     * @return {MenuLayout}\n     */\n    getMenuLayout () {\n        return this.getObject(MenuLayout, AddSubMenu.KEY_MENU_LAYOUT);\n    }\n}\n\nAddSubMenu.KEY_MENU_ID = 'menuID';\nAddSubMenu.KEY_POSITION = 'position';\nAddSubMenu.KEY_MENU_NAME = 'menuName';\nAddSubMenu.KEY_MENU_ICON = 'menuIcon';\nAddSubMenu.KEY_MENU_LAYOUT = 'menuLayout';\n\nexport { AddSubMenu };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass AddSubMenuResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AddSubMenu);\n    }\n}\n\n\nexport { AddSubMenuResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Deletes a submenu from the in-application menu.\n */\nclass DeleteSubMenu extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteSubMenu);\n    }\n\n    /**\n     * @param {Number} id - The \"menuID\" of the submenu to delete. (See addSubMenu.menuID)\n     * @return {DeleteSubMenu}\n     */\n    setMenuID (id) {\n        this.setParameter(DeleteSubMenu.KEY_MENU_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMenuID () {\n        return this.getParameter(DeleteSubMenu.KEY_MENU_ID);\n    }\n}\n\nDeleteSubMenu.KEY_MENU_ID = 'menuID';\n\nexport { DeleteSubMenu };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass DeleteSubMenuResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteSubMenu);\n    }\n}\n\n\nexport { DeleteSubMenuResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Shows the built in menu view\n */\nclass ShowAppMenu extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ShowAppMenu);\n    }\n\n    /**\n     * @param {Number} id - If omitted the HMI opens the app's menu. If set to a sub-menu ID the HMI opens the\n     *                      corresponding sub-menu previously added using `AddSubMenu`.\n     * @return {ShowAppMenu}\n     */\n    setMenuID (id) {\n        this.setParameter(ShowAppMenu.KEY_MENU_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMenuID () {\n        return this.getParameter(ShowAppMenu.KEY_MENU_ID);\n    }\n}\n\nShowAppMenu.KEY_MENU_ID = 'menuID';\n\nexport { ShowAppMenu };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ShowAppMenuResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ShowAppMenu);\n    }\n}\n\n\nexport { ShowAppMenuResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { Image } from './Image.js';\n\n/**\n * A choice is an option given to the user, which can be selected either by menu, or through voice recognition system.\n */\nclass Choice extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} id\n     * @return {Choice}\n     */\n    setChoiceID (id) {\n        this.setParameter(Choice.KEY_CHOICE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getChoiceID () {\n        return this.getParameter(Choice.KEY_CHOICE_ID);\n    }\n\n    /**\n     * @param {String} name\n     * @return {Choice}\n     */\n    setMenuName (name) {\n        this.setParameter(Choice.KEY_MENU_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMenuName () {\n        return this.getParameter(Choice.KEY_MENU_NAME);\n    }\n\n    /**\n     * @param {String[]} commands\n     * @return {Choice}\n     */\n    setVrCommands (commands) {\n        this.setParameter(Choice.KEY_VR_COMMANDS, commands);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getVrCommands () {\n        return this.getParameter(Choice.KEY_VR_COMMANDS);\n    }\n\n    /**\n     * @param {Image} image\n     * @return {Choice}\n     */\n    setImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(Choice.KEY_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getImage () {\n        return this.getObject(Image, Choice.KEY_IMAGE);\n    }\n\n    /**\n     * @param {String} text - Optional secondary text to display; e.g. address of POI in a search result entry\n     * @return {Choice}\n     */\n    setSecondaryText (text) {\n        this.setParameter(Choice.KEY_SECONDARY_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSecondaryText () {\n        return this.getParameter(Choice.KEY_SECONDARY_TEXT);\n    }\n\n    /**\n     * @param {String} text - Optional tertiary text to display; e.g. distance to POI for a search result entry\n     * @return {Choice}\n     */\n    setTertiaryText (text) {\n        this.setParameter(Choice.KEY_TERTIARY_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getTertiaryText () {\n        return this.getParameter(Choice.KEY_TERTIARY_TEXT);\n    }\n\n    /**\n     * @param {Image} image - Optional secondary image struct for choice\n     * @return {Choice}\n     */\n    setSecondaryImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(Choice.KEY_SECONDARY_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getSecondaryImage () {\n        return this.getObject(Image, Choice.KEY_SECONDARY_IMAGE);\n    }\n}\n\nChoice.KEY_CHOICE_ID = 'choiceID';\nChoice.KEY_MENU_NAME = 'menuName';\nChoice.KEY_VR_COMMANDS = 'vrCommands';\nChoice.KEY_IMAGE = 'image';\nChoice.KEY_SECONDARY_TEXT = 'secondaryText';\nChoice.KEY_TERTIARY_TEXT = 'tertiaryText';\nChoice.KEY_SECONDARY_IMAGE = 'secondaryImage';\n\nexport { Choice };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { Choice } from '../structs/Choice.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * creates interaction choice set to be used later by performInteraction\n */\nclass CreateInteractionChoiceSet extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CreateInteractionChoiceSet);\n    }\n\n    /**\n     * @param {Number} id - Unique ID used for this interaction choice set.\n     * @return {CreateInteractionChoiceSet}\n     */\n    setInteractionChoiceSetID (id) {\n        this.setParameter(CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getInteractionChoiceSetID () {\n        return this.getParameter(CreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID);\n    }\n\n    /**\n     * @param {Choice[]} set - A choice is an option given to the user, which can be selected either by menu, or through\n     *                         voice recognition system.\n     * @return {CreateInteractionChoiceSet}\n     */\n    setChoiceSet (set) {\n        this.validateType(Choice, set, true);\n        this.setParameter(CreateInteractionChoiceSet.KEY_CHOICE_SET, set);\n        return this;\n    }\n\n    /**\n     * @return {Choice[]}\n     */\n    getChoiceSet () {\n        return this.getObject(Choice, CreateInteractionChoiceSet.KEY_CHOICE_SET);\n    }\n}\n\nCreateInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID = 'interactionChoiceSetID';\nCreateInteractionChoiceSet.KEY_CHOICE_SET = 'choiceSet';\n\nexport { CreateInteractionChoiceSet };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass CreateInteractionChoiceSetResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CreateInteractionChoiceSet);\n    }\n}\n\n\nexport { CreateInteractionChoiceSetResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * For touchscreen interactions, the mode of how the choices are presented.\n * @typedef {Enum} LayoutMode\n * @property {Object} _MAP\n */\nclass LayoutMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * This mode causes the interaction to display the previous set of choices as icons.\n     * @return {String}\n     */\n    static get ICON_ONLY () {\n        return LayoutMode._MAP.ICON_ONLY;\n    }\n\n    /**\n     * This mode causes the interaction to display the previous set of choices as icons along with a search field in\n     * the HMI.\n     * @return {String}\n     */\n    static get ICON_WITH_SEARCH () {\n        return LayoutMode._MAP.ICON_WITH_SEARCH;\n    }\n\n    /**\n     * This mode causes the interaction to display the previous set of choices as a list.\n     * @return {String}\n     */\n    static get LIST_ONLY () {\n        return LayoutMode._MAP.LIST_ONLY;\n    }\n\n    /**\n     * This mode causes the interaction to display the previous set of choices as a list along with a search field in\n     * the HMI.\n     * @return {String}\n     */\n    static get LIST_WITH_SEARCH () {\n        return LayoutMode._MAP.LIST_WITH_SEARCH;\n    }\n\n    /**\n     * This mode causes the interaction to immediately display a keyboard entry through the HMI.\n     * @return {String}\n     */\n    static get KEYBOARD () {\n        return LayoutMode._MAP.KEYBOARD;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return LayoutMode._valueForKey(key, LayoutMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return LayoutMode._keyForValue(value, LayoutMode._MAP);\n    }\n}\n\nLayoutMode._MAP = Object.freeze({\n    'ICON_ONLY': 'ICON_ONLY',\n    'ICON_WITH_SEARCH': 'ICON_WITH_SEARCH',\n    'LIST_ONLY': 'LIST_ONLY',\n    'LIST_WITH_SEARCH': 'LIST_WITH_SEARCH',\n    'KEYBOARD': 'KEYBOARD',\n});\n\nexport { LayoutMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * For application-requested interactions, this mode indicates the method in which the user is notified and uses the\n * interaction.\n * @typedef {Enum} InteractionMode\n * @property {Object} _MAP\n */\nclass InteractionMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * This mode causes the interaction to only occur on the display, meaning the choices are provided only via the\n     * display. No Voice Interaction.\n     * @return {String}\n     */\n    static get MANUAL_ONLY () {\n        return InteractionMode._MAP.MANUAL_ONLY;\n    }\n\n    /**\n     * This mode causes the interaction to only occur using the headunits VR system. Selections are made by saying the\n     * command.\n     * @return {String}\n     */\n    static get VR_ONLY () {\n        return InteractionMode._MAP.VR_ONLY;\n    }\n\n    /**\n     * This mode causes both a VR and display selection option for an interaction. The user will first be asked via\n     * Voice Interaction (if available). If this is unsuccessful, the system will switch to manual input.\n     * @return {String}\n     */\n    static get BOTH () {\n        return InteractionMode._MAP.BOTH;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return InteractionMode._valueForKey(key, InteractionMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return InteractionMode._keyForValue(value, InteractionMode._MAP);\n    }\n}\n\nInteractionMode._MAP = Object.freeze({\n    'MANUAL_ONLY': 'MANUAL_ONLY',\n    'VR_ONLY': 'VR_ONLY',\n    'BOTH': 'BOTH',\n});\n\nexport { InteractionMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { VrHelpItem } from '../structs/VrHelpItem.js';\nimport { LayoutMode } from '../enums/LayoutMode.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { InteractionMode } from '../enums/InteractionMode.js';\n\n/**\n * Triggers an interaction (e.g. \"Permit GPS?\" - Yes, no, Always Allow).\n */\nclass PerformInteraction extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PerformInteraction);\n    }\n\n    /**\n     * @param {String} text - Text to be displayed first.\n     * @return {PerformInteraction}\n     */\n    setInitialText (text) {\n        this.setParameter(PerformInteraction.KEY_INITIAL_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getInitialText () {\n        return this.getParameter(PerformInteraction.KEY_INITIAL_TEXT);\n    }\n\n    /**\n     * @param {TTSChunk[]} prompt - This is the initial prompt spoken to the user at the start of an interaction. An\n     *                              array of text chunks of type TTSChunk. See TTSChunk. The array must have at least\n     *                              one item.\n     * @return {PerformInteraction}\n     */\n    setInitialPrompt (prompt) {\n        this.validateType(TTSChunk, prompt, true);\n        this.setParameter(PerformInteraction.KEY_INITIAL_PROMPT, prompt);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getInitialPrompt () {\n        return this.getObject(TTSChunk, PerformInteraction.KEY_INITIAL_PROMPT);\n    }\n\n    /**\n     * @param {InteractionMode} mode - See InteractionMode.\n     * @return {PerformInteraction}\n     */\n    setInteractionMode (mode) {\n        this.validateType(InteractionMode, mode);\n        this.setParameter(PerformInteraction.KEY_INTERACTION_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {InteractionMode}\n     */\n    getInteractionMode () {\n        return this.getObject(InteractionMode, PerformInteraction.KEY_INTERACTION_MODE);\n    }\n\n    /**\n     * @param {Number[]} list - List of interaction choice set IDs to use with an interaction.\n     * @return {PerformInteraction}\n     */\n    setInteractionChoiceSetIDList (list) {\n        this.setParameter(PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST, list);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getInteractionChoiceSetIDList () {\n        return this.getParameter(PerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST);\n    }\n\n    /**\n     * @param {TTSChunk[]} prompt - Help text. This is the spoken string when a user speaks \"help\" when the interaction\n     *                              is occurring. An array of text chunks of type TTSChunk. See TTSChunk. The array must\n     *                              have at least one item.\n     * @return {PerformInteraction}\n     */\n    setHelpPrompt (prompt) {\n        this.validateType(TTSChunk, prompt, true);\n        this.setParameter(PerformInteraction.KEY_HELP_PROMPT, prompt);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getHelpPrompt () {\n        return this.getObject(TTSChunk, PerformInteraction.KEY_HELP_PROMPT);\n    }\n\n    /**\n     * @param {TTSChunk[]} prompt - Timeout text. This text is spoken when a VR interaction times out. An array of text\n     *                              chunks of type TTSChunk. See TTSChunk. The array must have at least one item.\n     * @return {PerformInteraction}\n     */\n    setTimeoutPrompt (prompt) {\n        this.validateType(TTSChunk, prompt, true);\n        this.setParameter(PerformInteraction.KEY_TIMEOUT_PROMPT, prompt);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getTimeoutPrompt () {\n        return this.getObject(TTSChunk, PerformInteraction.KEY_TIMEOUT_PROMPT);\n    }\n\n    /**\n     * @param {Number} timeout - Timeout in milliseconds. If omitted a standard value of 10000 milliseconds is used.\n     *                           Applies only to the menu portion of the interaction. The VR timeout will be handled by\n     *                           the platform.\n     * @return {PerformInteraction}\n     */\n    setTimeout (timeout) {\n        this.setParameter(PerformInteraction.KEY_TIMEOUT, timeout);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTimeout () {\n        return this.getParameter(PerformInteraction.KEY_TIMEOUT);\n    }\n\n    /**\n     * @param {VrHelpItem[]} help - Ability to send suggested VR Help Items to display on-screen during Perform\n     *                              Interaction. If omitted on supported displays, the default generated list of\n     *                              suggested choices shall be displayed.\n     * @return {PerformInteraction}\n     */\n    setVrHelp (help) {\n        this.validateType(VrHelpItem, help, true);\n        this.setParameter(PerformInteraction.KEY_VR_HELP, help);\n        return this;\n    }\n\n    /**\n     * @return {VrHelpItem[]}\n     */\n    getVrHelp () {\n        return this.getObject(VrHelpItem, PerformInteraction.KEY_VR_HELP);\n    }\n\n    /**\n     * @param {LayoutMode} layout - See LayoutMode.\n     * @return {PerformInteraction}\n     */\n    setInteractionLayout (layout) {\n        this.validateType(LayoutMode, layout);\n        this.setParameter(PerformInteraction.KEY_INTERACTION_LAYOUT, layout);\n        return this;\n    }\n\n    /**\n     * @return {LayoutMode}\n     */\n    getInteractionLayout () {\n        return this.getObject(LayoutMode, PerformInteraction.KEY_INTERACTION_LAYOUT);\n    }\n\n    /**\n     * @param {Number} id - An ID for this specific PerformInteraction to allow cancellation through the\n     *                      `CancelInteraction` RPC.\n     * @return {PerformInteraction}\n     */\n    setCancelID (id) {\n        this.setParameter(PerformInteraction.KEY_CANCEL_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCancelID () {\n        return this.getParameter(PerformInteraction.KEY_CANCEL_ID);\n    }\n}\n\nPerformInteraction.KEY_INITIAL_TEXT = 'initialText';\nPerformInteraction.KEY_INITIAL_PROMPT = 'initialPrompt';\nPerformInteraction.KEY_INTERACTION_MODE = 'interactionMode';\nPerformInteraction.KEY_INTERACTION_CHOICE_SET_IDLIST = 'interactionChoiceSetIDList';\nPerformInteraction.KEY_HELP_PROMPT = 'helpPrompt';\nPerformInteraction.KEY_TIMEOUT_PROMPT = 'timeoutPrompt';\nPerformInteraction.KEY_TIMEOUT = 'timeout';\nPerformInteraction.KEY_VR_HELP = 'vrHelp';\nPerformInteraction.KEY_INTERACTION_LAYOUT = 'interactionLayout';\nPerformInteraction.KEY_CANCEL_ID = 'cancelID';\n\nexport { PerformInteraction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Indicates the source from where the command was triggered.\n * @typedef {Enum} TriggerSource\n * @property {Object} _MAP\n */\nclass TriggerSource extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TS_MENU () {\n        return TriggerSource._MAP.TS_MENU;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TS_VR () {\n        return TriggerSource._MAP.TS_VR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TS_KEYBOARD () {\n        return TriggerSource._MAP.TS_KEYBOARD;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TriggerSource._valueForKey(key, TriggerSource._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TriggerSource._keyForValue(value, TriggerSource._MAP);\n    }\n}\n\nTriggerSource._MAP = Object.freeze({\n    'TS_MENU': 'MENU',\n    'TS_VR': 'VR',\n    'TS_KEYBOARD': 'KEYBOARD',\n});\n\nexport { TriggerSource };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TriggerSource } from '../enums/TriggerSource.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass PerformInteractionResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PerformInteraction);\n    }\n\n    /**\n     * @param {Number} id - ID of the choice that was selected in response to PerformInteraction. Only is valid if\n     *                      general result is \"success:true\".\n     * @return {PerformInteractionResponse}\n     */\n    setChoiceID (id) {\n        this.setParameter(PerformInteractionResponse.KEY_CHOICE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getChoiceID () {\n        return this.getParameter(PerformInteractionResponse.KEY_CHOICE_ID);\n    }\n\n    /**\n     * @param {String} entry - Manually entered text selection, e.g. through keyboard Can be returned in lieu of\n     *                         choiceID, depending on trigger source\n     * @return {PerformInteractionResponse}\n     */\n    setManualTextEntry (entry) {\n        this.setParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY, entry);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getManualTextEntry () {\n        return this.getParameter(PerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY);\n    }\n\n    /**\n     * @param {TriggerSource} source - See TriggerSource Only is valid if resultCode is SUCCESS.\n     * @return {PerformInteractionResponse}\n     */\n    setTriggerSource (source) {\n        this.validateType(TriggerSource, source);\n        this.setParameter(PerformInteractionResponse.KEY_TRIGGER_SOURCE, source);\n        return this;\n    }\n\n    /**\n     * @return {TriggerSource}\n     */\n    getTriggerSource () {\n        return this.getObject(TriggerSource, PerformInteractionResponse.KEY_TRIGGER_SOURCE);\n    }\n}\n\nPerformInteractionResponse.KEY_CHOICE_ID = 'choiceID';\nPerformInteractionResponse.KEY_MANUAL_TEXT_ENTRY = 'manualTextEntry';\nPerformInteractionResponse.KEY_TRIGGER_SOURCE = 'triggerSource';\n\nexport { PerformInteractionResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Deletes interaction choice set that has been created with \"CreateInteractionChoiceSet\". The interaction may only be\n * deleted when not currently in use by a \"performInteraction\".\n */\nclass DeleteInteractionChoiceSet extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteInteractionChoiceSet);\n    }\n\n    /**\n     * @param {Number} id - ID of the interaction choice set to delete.\n     * @return {DeleteInteractionChoiceSet}\n     */\n    setInteractionChoiceSetID (id) {\n        this.setParameter(DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getInteractionChoiceSetID () {\n        return this.getParameter(DeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID);\n    }\n}\n\nDeleteInteractionChoiceSet.KEY_INTERACTION_CHOICE_SET_ID = 'interactionChoiceSetID';\n\nexport { DeleteInteractionChoiceSet };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass DeleteInteractionChoiceSetResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteInteractionChoiceSet);\n    }\n}\n\n\nexport { DeleteInteractionChoiceSetResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Contains information about the SoftButton capabilities.\n * @typedef {Enum} SoftButtonType\n * @property {Object} _MAP\n */\nclass SoftButtonType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SBT_TEXT () {\n        return SoftButtonType._MAP.SBT_TEXT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SBT_IMAGE () {\n        return SoftButtonType._MAP.SBT_IMAGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SBT_BOTH () {\n        return SoftButtonType._MAP.SBT_BOTH;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SoftButtonType._valueForKey(key, SoftButtonType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SoftButtonType._keyForValue(value, SoftButtonType._MAP);\n    }\n}\n\nSoftButtonType._MAP = Object.freeze({\n    'SBT_TEXT': 'TEXT',\n    'SBT_IMAGE': 'IMAGE',\n    'SBT_BOTH': 'BOTH',\n});\n\nexport { SoftButtonType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes system actions that can be triggered.\n * @typedef {Enum} SystemAction\n * @property {Object} _MAP\n */\nclass SystemAction extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Default action occurs. Standard behavior (e.g. SoftButton clears overlay).\n     * @return {String}\n     */\n    static get DEFAULT_ACTION () {\n        return SystemAction._MAP.DEFAULT_ACTION;\n    }\n\n    /**\n     * App is brought into HMI_FULL.\n     * @return {String}\n     */\n    static get STEAL_FOCUS () {\n        return SystemAction._MAP.STEAL_FOCUS;\n    }\n\n    /**\n     * Current system context is maintained. An overlay is persisted even though a SoftButton has been pressed and the\n     * notification sent.\n     * @return {String}\n     */\n    static get KEEP_CONTEXT () {\n        return SystemAction._MAP.KEEP_CONTEXT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SystemAction._valueForKey(key, SystemAction._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SystemAction._keyForValue(value, SystemAction._MAP);\n    }\n}\n\nSystemAction._MAP = Object.freeze({\n    'DEFAULT_ACTION': 'DEFAULT_ACTION',\n    'STEAL_FOCUS': 'STEAL_FOCUS',\n    'KEEP_CONTEXT': 'KEEP_CONTEXT',\n});\n\nexport { SystemAction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SoftButtonType } from '../enums/SoftButtonType.js';\nimport { Image } from './Image.js';\nimport { SystemAction } from '../enums/SystemAction.js';\n\nclass SoftButton extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {SoftButtonType} type - Describes, whether it is text, highlighted text, icon, or dynamic image. See\n     *                                softButtonType\n     * @return {SoftButton}\n     */\n    setType (type) {\n        this.validateType(SoftButtonType, type);\n        this.setParameter(SoftButton.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {SoftButtonType}\n     */\n    getType () {\n        return this.getObject(SoftButtonType, SoftButton.KEY_TYPE);\n    }\n\n    /**\n     * @param {String} text - Optional text to display (if defined as TEXT or BOTH)\n     * @return {SoftButton}\n     */\n    setText (text) {\n        this.setParameter(SoftButton.KEY_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getText () {\n        return this.getParameter(SoftButton.KEY_TEXT);\n    }\n\n    /**\n     * @param {Image} image - Optional image struct for SoftButton (if defined as IMAGE or BOTH)\n     * @return {SoftButton}\n     */\n    setImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(SoftButton.KEY_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getImage () {\n        return this.getObject(Image, SoftButton.KEY_IMAGE);\n    }\n\n    /**\n     * @param {Boolean} highlighted - True, if highlighted False, if not highlighted\n     * @return {SoftButton}\n     */\n    setIsHighlighted (highlighted) {\n        this.setParameter(SoftButton.KEY_IS_HIGHLIGHTED, highlighted);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getIsHighlighted () {\n        return this.getParameter(SoftButton.KEY_IS_HIGHLIGHTED);\n    }\n\n    /**\n     * @param {Number} id - Value which is returned via OnButtonPress / OnButtonEvent\n     * @return {SoftButton}\n     */\n    setSoftButtonID (id) {\n        this.setParameter(SoftButton.KEY_SOFT_BUTTON_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSoftButtonID () {\n        return this.getParameter(SoftButton.KEY_SOFT_BUTTON_ID);\n    }\n\n    /**\n     * @param {SystemAction} action - Parameter indicating whether selecting a SoftButton shall call a specific system\n     *                                action. This is intended to allow Notifications to bring the callee into full /\n     *                                focus; or in the case of persistent overlays, the overlay can persist when a\n     *                                SoftButton is pressed.\n     * @return {SoftButton}\n     */\n    setSystemAction (action) {\n        this.validateType(SystemAction, action);\n        this.setParameter(SoftButton.KEY_SYSTEM_ACTION, action);\n        return this;\n    }\n\n    /**\n     * @return {SystemAction}\n     */\n    getSystemAction () {\n        return this.getObject(SystemAction, SoftButton.KEY_SYSTEM_ACTION);\n    }\n}\n\nSoftButton.KEY_TYPE = 'type';\nSoftButton.KEY_TEXT = 'text';\nSoftButton.KEY_IMAGE = 'image';\nSoftButton.KEY_IS_HIGHLIGHTED = 'isHighlighted';\nSoftButton.KEY_SOFT_BUTTON_ID = 'softButtonID';\nSoftButton.KEY_SYSTEM_ACTION = 'systemAction';\n\nexport { SoftButton };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { SoftButton } from '../structs/SoftButton.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { Image } from '../structs/Image.js';\n\n/**\n * Shows an alert which typically consists of text-to-speech message and text on the display. At least either\n * alertText1, alertText2 or TTSChunks need to be provided.\n */\nclass Alert extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Alert);\n    }\n\n    /**\n     * @param {String} text1 - The first line of the alert text field\n     * @return {Alert}\n     */\n    setAlertText1 (text1) {\n        this.setParameter(Alert.KEY_ALERT_TEXT_1, text1);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAlertText1 () {\n        return this.getParameter(Alert.KEY_ALERT_TEXT_1);\n    }\n\n    /**\n     * @param {String} text2 - The second line of the alert text field\n     * @return {Alert}\n     */\n    setAlertText2 (text2) {\n        this.setParameter(Alert.KEY_ALERT_TEXT_2, text2);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAlertText2 () {\n        return this.getParameter(Alert.KEY_ALERT_TEXT_2);\n    }\n\n    /**\n     * @param {String} text3 - The optional third line of the alert text field\n     * @return {Alert}\n     */\n    setAlertText3 (text3) {\n        this.setParameter(Alert.KEY_ALERT_TEXT_3, text3);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAlertText3 () {\n        return this.getParameter(Alert.KEY_ALERT_TEXT_3);\n    }\n\n    /**\n     * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least\n     *                              one item.\n     * @return {Alert}\n     */\n    setTtsChunks (chunks) {\n        this.validateType(TTSChunk, chunks, true);\n        this.setParameter(Alert.KEY_TTS_CHUNKS, chunks);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getTtsChunks () {\n        return this.getObject(TTSChunk, Alert.KEY_TTS_CHUNKS);\n    }\n\n    /**\n     * @param {Number} duration - Timeout in milliseconds. Typical timeouts are 3-5 seconds. If omitted, timeout is set\n     *                            to 5s.\n     * @return {Alert}\n     */\n    setDuration (duration) {\n        this.setParameter(Alert.KEY_DURATION, duration);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDuration () {\n        return this.getParameter(Alert.KEY_DURATION);\n    }\n\n    /**\n     * @param {Boolean} tone - Defines if tone should be played. Tone is played before TTS. If omitted, no tone is\n     *                         played.\n     * @return {Alert}\n     */\n    setPlayTone (tone) {\n        this.setParameter(Alert.KEY_PLAY_TONE, tone);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPlayTone () {\n        return this.getParameter(Alert.KEY_PLAY_TONE);\n    }\n\n    /**\n     * @param {Boolean} indicator - If supported on the given platform, the alert GUI will include some sort of\n     *                              animation indicating that loading of a feature is progressing. e.g. a spinning wheel\n     *                              or hourglass, etc.\n     * @return {Alert}\n     */\n    setProgressIndicator (indicator) {\n        this.setParameter(Alert.KEY_PROGRESS_INDICATOR, indicator);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getProgressIndicator () {\n        return this.getParameter(Alert.KEY_PROGRESS_INDICATOR);\n    }\n\n    /**\n     * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, the displayed alert\n     *                                 shall not have any SoftButtons.\n     * @return {Alert}\n     */\n    setSoftButtons (buttons) {\n        this.validateType(SoftButton, buttons, true);\n        this.setParameter(Alert.KEY_SOFT_BUTTONS, buttons);\n        return this;\n    }\n\n    /**\n     * @return {SoftButton[]}\n     */\n    getSoftButtons () {\n        return this.getObject(SoftButton, Alert.KEY_SOFT_BUTTONS);\n    }\n\n    /**\n     * @param {Image} icon - Image struct determining whether static or dynamic icon. If omitted on supported displays,\n     *                       no (or the default if applicable) icon should be displayed.\n     * @return {Alert}\n     */\n    setAlertIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(Alert.KEY_ALERT_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getAlertIcon () {\n        return this.getObject(Image, Alert.KEY_ALERT_ICON);\n    }\n\n    /**\n     * @param {Number} id - An ID for this specific alert to allow cancellation through the `CancelInteraction` RPC.\n     * @return {Alert}\n     */\n    setCancelID (id) {\n        this.setParameter(Alert.KEY_CANCEL_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCancelID () {\n        return this.getParameter(Alert.KEY_CANCEL_ID);\n    }\n}\n\nAlert.KEY_ALERT_TEXT_1 = 'alertText1';\nAlert.KEY_ALERT_TEXT_2 = 'alertText2';\nAlert.KEY_ALERT_TEXT_3 = 'alertText3';\nAlert.KEY_TTS_CHUNKS = 'ttsChunks';\nAlert.KEY_DURATION = 'duration';\nAlert.KEY_PLAY_TONE = 'playTone';\nAlert.KEY_PROGRESS_INDICATOR = 'progressIndicator';\nAlert.KEY_SOFT_BUTTONS = 'softButtons';\nAlert.KEY_ALERT_ICON = 'alertIcon';\nAlert.KEY_CANCEL_ID = 'cancelID';\n\nexport { Alert };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass AlertResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Alert);\n    }\n\n    /**\n     * @param {Number} time - Amount of time (in seconds) that an app must wait before resending an alert. If provided,\n     *                        another system event or overlay currently has a higher priority than this alert. An app\n     *                        must not send an alert without waiting at least the amount of time dictated.\n     * @return {AlertResponse}\n     */\n    setTryAgainTime (time) {\n        this.setParameter(AlertResponse.KEY_TRY_AGAIN_TIME, time);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTryAgainTime () {\n        return this.getParameter(AlertResponse.KEY_TRY_AGAIN_TIME);\n    }\n}\n\nAlertResponse.KEY_TRY_AGAIN_TIME = 'tryAgainTime';\n\nexport { AlertResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The list of possible alignments, left, right, or centered\n * @typedef {Enum} TextAlignment\n * @property {Object} _MAP\n */\nclass TextAlignment extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LEFT_ALIGNED () {\n        return TextAlignment._MAP.LEFT_ALIGNED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RIGHT_ALIGNED () {\n        return TextAlignment._MAP.RIGHT_ALIGNED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CENTERED () {\n        return TextAlignment._MAP.CENTERED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TextAlignment._valueForKey(key, TextAlignment._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TextAlignment._keyForValue(value, TextAlignment._MAP);\n    }\n}\n\nTextAlignment._MAP = Object.freeze({\n    'LEFT_ALIGNED': 'LEFT_ALIGNED',\n    'RIGHT_ALIGNED': 'RIGHT_ALIGNED',\n    'CENTERED': 'CENTERED',\n});\n\nexport { TextAlignment };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { TemplateColorScheme } from './TemplateColorScheme.js';\n\nclass TemplateConfiguration extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} template - Predefined or dynamically created window template. Currently only predefined window\n     *                            template layouts are defined.\n     * @return {TemplateConfiguration}\n     */\n    setTemplate (template) {\n        this.setParameter(TemplateConfiguration.KEY_TEMPLATE, template);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getTemplate () {\n        return this.getParameter(TemplateConfiguration.KEY_TEMPLATE);\n    }\n\n    /**\n     * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates.\n     * @return {TemplateConfiguration}\n     */\n    setDayColorScheme (scheme) {\n        this.validateType(TemplateColorScheme, scheme);\n        this.setParameter(TemplateConfiguration.KEY_DAY_COLOR_SCHEME, scheme);\n        return this;\n    }\n\n    /**\n     * @return {TemplateColorScheme}\n     */\n    getDayColorScheme () {\n        return this.getObject(TemplateColorScheme, TemplateConfiguration.KEY_DAY_COLOR_SCHEME);\n    }\n\n    /**\n     * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates.\n     * @return {TemplateConfiguration}\n     */\n    setNightColorScheme (scheme) {\n        this.validateType(TemplateColorScheme, scheme);\n        this.setParameter(TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME, scheme);\n        return this;\n    }\n\n    /**\n     * @return {TemplateColorScheme}\n     */\n    getNightColorScheme () {\n        return this.getObject(TemplateColorScheme, TemplateConfiguration.KEY_NIGHT_COLOR_SCHEME);\n    }\n}\n\nTemplateConfiguration.KEY_TEMPLATE = 'template';\nTemplateConfiguration.KEY_DAY_COLOR_SCHEME = 'dayColorScheme';\nTemplateConfiguration.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme';\n\nexport { TemplateConfiguration };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} MetadataType\n * @property {Object} _MAP\n */\nclass MetadataType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The data in this field contains the title of the currently playing audio track.\n     * @return {String}\n     */\n    static get mediaTitle () {\n        return MetadataType._MAP.mediaTitle;\n    }\n\n    /**\n     * The data in this field contains the artist or creator of the currently playing audio track.\n     * @return {String}\n     */\n    static get mediaArtist () {\n        return MetadataType._MAP.mediaArtist;\n    }\n\n    /**\n     * The data in this field contains the album title of the currently playing audio track.\n     * @return {String}\n     */\n    static get mediaAlbum () {\n        return MetadataType._MAP.mediaAlbum;\n    }\n\n    /**\n     * The data in this field contains the creation year of the currently playing audio track.\n     * @return {String}\n     */\n    static get mediaYear () {\n        return MetadataType._MAP.mediaYear;\n    }\n\n    /**\n     * The data in this field contains the genre of the currently playing audio track.\n     * @return {String}\n     */\n    static get mediaGenre () {\n        return MetadataType._MAP.mediaGenre;\n    }\n\n    /**\n     * The data in this field contains the name of the current source for the media.\n     * @return {String}\n     */\n    static get mediaStation () {\n        return MetadataType._MAP.mediaStation;\n    }\n\n    /**\n     * The data in this field is a rating.\n     * @return {String}\n     */\n    static get rating () {\n        return MetadataType._MAP.rating;\n    }\n\n    /**\n     * The data in this field is the current temperature.\n     * @return {String}\n     */\n    static get currentTemperature () {\n        return MetadataType._MAP.currentTemperature;\n    }\n\n    /**\n     * The data in this field is the maximum temperature for the day.\n     * @return {String}\n     */\n    static get maximumTemperature () {\n        return MetadataType._MAP.maximumTemperature;\n    }\n\n    /**\n     * The data in this field is the minimum temperature for the day.\n     * @return {String}\n     */\n    static get minimumTemperature () {\n        return MetadataType._MAP.minimumTemperature;\n    }\n\n    /**\n     * The data in this field describes the current weather (ex. cloudy, clear, etc.).\n     * @return {String}\n     */\n    static get weatherTerm () {\n        return MetadataType._MAP.weatherTerm;\n    }\n\n    /**\n     * The data in this field describes the current humidity value.\n     * @return {String}\n     */\n    static get humidity () {\n        return MetadataType._MAP.humidity;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MetadataType._valueForKey(key, MetadataType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MetadataType._keyForValue(value, MetadataType._MAP);\n    }\n}\n\nMetadataType._MAP = Object.freeze({\n    'mediaTitle': 'mediaTitle',\n    'mediaArtist': 'mediaArtist',\n    'mediaAlbum': 'mediaAlbum',\n    'mediaYear': 'mediaYear',\n    'mediaGenre': 'mediaGenre',\n    'mediaStation': 'mediaStation',\n    'rating': 'rating',\n    'currentTemperature': 'currentTemperature',\n    'maximumTemperature': 'maximumTemperature',\n    'minimumTemperature': 'minimumTemperature',\n    'weatherTerm': 'weatherTerm',\n    'humidity': 'humidity',\n});\n\nexport { MetadataType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { MetadataType } from '../enums/MetadataType.js';\n\nclass MetadataTags extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {MetadataType[]} field1 - The type of data contained in the \"mainField1\" text field.\n     * @return {MetadataTags}\n     */\n    setMainField1 (field1) {\n        this.validateType(MetadataType, field1, true);\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_1, field1);\n        return this;\n    }\n\n    /**\n     * @return {MetadataType[]}\n     */\n    getMainField1 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_1);\n    }\n\n    /**\n     * @param {MetadataType[]} field2 - The type of data contained in the \"mainField2\" text field.\n     * @return {MetadataTags}\n     */\n    setMainField2 (field2) {\n        this.validateType(MetadataType, field2, true);\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_2, field2);\n        return this;\n    }\n\n    /**\n     * @return {MetadataType[]}\n     */\n    getMainField2 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_2);\n    }\n\n    /**\n     * @param {MetadataType[]} field3 - The type of data contained in the \"mainField3\" text field.\n     * @return {MetadataTags}\n     */\n    setMainField3 (field3) {\n        this.validateType(MetadataType, field3, true);\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_3, field3);\n        return this;\n    }\n\n    /**\n     * @return {MetadataType[]}\n     */\n    getMainField3 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_3);\n    }\n\n    /**\n     * @param {MetadataType[]} field4 - The type of data contained in the \"mainField4\" text field.\n     * @return {MetadataTags}\n     */\n    setMainField4 (field4) {\n        this.validateType(MetadataType, field4, true);\n        this.setParameter(MetadataTags.KEY_MAIN_FIELD_4, field4);\n        return this;\n    }\n\n    /**\n     * @return {MetadataType[]}\n     */\n    getMainField4 () {\n        return this.getObject(MetadataType, MetadataTags.KEY_MAIN_FIELD_4);\n    }\n}\n\nMetadataTags.KEY_MAIN_FIELD_1 = 'mainField1';\nMetadataTags.KEY_MAIN_FIELD_2 = 'mainField2';\nMetadataTags.KEY_MAIN_FIELD_3 = 'mainField3';\nMetadataTags.KEY_MAIN_FIELD_4 = 'mainField4';\n\nexport { MetadataTags };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TextAlignment } from '../enums/TextAlignment.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { SoftButton } from '../structs/SoftButton.js';\nimport { TemplateConfiguration } from '../structs/TemplateConfiguration.js';\nimport { MetadataTags } from '../structs/MetadataTags.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { Image } from '../structs/Image.js';\n\n/**\n * Updates the persistent display. Supported fields depend on display capabilities.\n */\nclass Show extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Show);\n    }\n\n    /**\n     * @param {String} field1 - The text that should be displayed in a single or upper display line. If this text is not\n     *                          set, the text of mainField1 stays unchanged. If this text is empty \"\", the field will be\n     *                          cleared.\n     * @return {Show}\n     */\n    setMainField1 (field1) {\n        this.setParameter(Show.KEY_MAIN_FIELD_1, field1);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMainField1 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_1);\n    }\n\n    /**\n     * @param {String} field2 - The text that should be displayed on the second display line. If this text is not set,\n     *                          the text of mainField2 stays unchanged. If this text is empty \"\", the field will be\n     *                          cleared.\n     * @return {Show}\n     */\n    setMainField2 (field2) {\n        this.setParameter(Show.KEY_MAIN_FIELD_2, field2);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMainField2 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_2);\n    }\n\n    /**\n     * @param {String} field3 - The text that should be displayed on the second \"page\" first display line. If this text\n     *                          is not set, the text of mainField3 stays unchanged. If this text is empty \"\", the field\n     *                          will be cleared.\n     * @return {Show}\n     */\n    setMainField3 (field3) {\n        this.setParameter(Show.KEY_MAIN_FIELD_3, field3);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMainField3 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_3);\n    }\n\n    /**\n     * @param {String} field4 - The text that should be displayed on the second \"page\" second display line. If this text\n     *                          is not set, the text of mainField4 stays unchanged. If this text is empty \"\", the field\n     *                          will be cleared.\n     * @return {Show}\n     */\n    setMainField4 (field4) {\n        this.setParameter(Show.KEY_MAIN_FIELD_4, field4);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMainField4 () {\n        return this.getParameter(Show.KEY_MAIN_FIELD_4);\n    }\n\n    /**\n     * @param {TextAlignment} alignment - Specifies how mainField1 and mainField2 texts should be aligned on display. If\n     *                                    omitted, texts will be centered.\n     * @return {Show}\n     */\n    setAlignment (alignment) {\n        this.validateType(TextAlignment, alignment);\n        this.setParameter(Show.KEY_ALIGNMENT, alignment);\n        return this;\n    }\n\n    /**\n     * @return {TextAlignment}\n     */\n    getAlignment () {\n        return this.getObject(TextAlignment, Show.KEY_ALIGNMENT);\n    }\n\n    /**\n     * @param {String} bar - Requires investigation regarding the nav display capabilities. Potentially lower\n     *                       lowerStatusBar, upperStatusBar, titleBar, etc.\n     * @return {Show}\n     */\n    setStatusBar (bar) {\n        this.setParameter(Show.KEY_STATUS_BAR, bar);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getStatusBar () {\n        return this.getParameter(Show.KEY_STATUS_BAR);\n    }\n\n    /**\n     * @param {String} clock - Text value for MediaClock field. Has to be properly formatted by Mobile App according to\n     *                         the module's capabilities. If this text is set, any automatic media clock updates\n     *                         previously set with SetMediaClockTimer will be stopped.\n     * @return {Show}\n     */\n    setMediaClock (clock) {\n        this.setParameter(Show.KEY_MEDIA_CLOCK, clock);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMediaClock () {\n        return this.getParameter(Show.KEY_MEDIA_CLOCK);\n    }\n\n    /**\n     * @param {String} track - The text that should be displayed in the track field. If this text is not set, the text\n     *                         of mediaTrack stays unchanged. If this text is empty \"\", the field will be cleared.\n     * @return {Show}\n     */\n    setMediaTrack (track) {\n        this.setParameter(Show.KEY_MEDIA_TRACK, track);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMediaTrack () {\n        return this.getParameter(Show.KEY_MEDIA_TRACK);\n    }\n\n    /**\n     * @param {Image} graphic - Image struct determining whether static or dynamic image to display in app. If omitted\n     *                          on supported displays, the displayed graphic shall not change.\n     * @return {Show}\n     */\n    setGraphic (graphic) {\n        this.validateType(Image, graphic);\n        this.setParameter(Show.KEY_GRAPHIC, graphic);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getGraphic () {\n        return this.getObject(Image, Show.KEY_GRAPHIC);\n    }\n\n    /**\n     * @param {Image} graphic - Image struct determining whether static or dynamic secondary image to display in app. If\n     *                          omitted on supported displays, the displayed secondary graphic shall not change.\n     * @return {Show}\n     */\n    setSecondaryGraphic (graphic) {\n        this.validateType(Image, graphic);\n        this.setParameter(Show.KEY_SECONDARY_GRAPHIC, graphic);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getSecondaryGraphic () {\n        return this.getObject(Image, Show.KEY_SECONDARY_GRAPHIC);\n    }\n\n    /**\n     * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, the currently\n     *                                 displayed SoftButton values will not change.\n     * @return {Show}\n     */\n    setSoftButtons (buttons) {\n        this.validateType(SoftButton, buttons, true);\n        this.setParameter(Show.KEY_SOFT_BUTTONS, buttons);\n        return this;\n    }\n\n    /**\n     * @return {SoftButton[]}\n     */\n    getSoftButtons () {\n        return this.getObject(SoftButton, Show.KEY_SOFT_BUTTONS);\n    }\n\n    /**\n     * @param {String[]} presets - App labeled on-screen presets (i.e. on-screen media presets or dynamic search\n     *                             suggestions). If omitted on supported displays, the presets will be shown as not\n     *                             defined.\n     * @return {Show}\n     */\n    setCustomPresets (presets) {\n        this.setParameter(Show.KEY_CUSTOM_PRESETS, presets);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getCustomPresets () {\n        return this.getParameter(Show.KEY_CUSTOM_PRESETS);\n    }\n\n    /**\n     * @param {MetadataTags} tags - App defined metadata information. See MetadataStruct. Uses mainField1, mainField2,\n     *                              mainField3, mainField4. If omitted on supported displays, the currently set metadata\n     *                              tags will not change. If any text field contains no tags or the none tag, the\n     *                              metadata tag for that textfield should be removed.\n     * @return {Show}\n     */\n    setMetadataTags (tags) {\n        this.validateType(MetadataTags, tags);\n        this.setParameter(Show.KEY_METADATA_TAGS, tags);\n        return this;\n    }\n\n    /**\n     * @return {MetadataTags}\n     */\n    getMetadataTags () {\n        return this.getObject(MetadataTags, Show.KEY_METADATA_TAGS);\n    }\n\n    /**\n     * @param {String} title - The title of the new template that will be displayed. How this will be displayed is\n     *                         dependent on the OEM design and implementation of the template.\n     * @return {Show}\n     */\n    setTemplateTitle (title) {\n        this.setParameter(Show.KEY_TEMPLATE_TITLE, title);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getTemplateTitle () {\n        return this.getParameter(Show.KEY_TEMPLATE_TITLE);\n    }\n\n    /**\n     * @param {Number} id - This is the unique ID assigned to the window that this RPC is intended. If this param is not\n     *                      included, it will be assumed that this request is specifically for the main window on the\n     *                      main display. See PredefinedWindows enum.\n     * @return {Show}\n     */\n    setWindowID (id) {\n        this.setParameter(Show.KEY_WINDOW_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindowID () {\n        return this.getParameter(Show.KEY_WINDOW_ID);\n    }\n\n    /**\n     * @param {TemplateConfiguration} configuration - Used to set an alternate template layout to a window.\n     * @return {Show}\n     */\n    setTemplateConfiguration (configuration) {\n        this.validateType(TemplateConfiguration, configuration);\n        this.setParameter(Show.KEY_TEMPLATE_CONFIGURATION, configuration);\n        return this;\n    }\n\n    /**\n     * @return {TemplateConfiguration}\n     */\n    getTemplateConfiguration () {\n        return this.getObject(TemplateConfiguration, Show.KEY_TEMPLATE_CONFIGURATION);\n    }\n}\n\nShow.KEY_MAIN_FIELD_1 = 'mainField1';\nShow.KEY_MAIN_FIELD_2 = 'mainField2';\nShow.KEY_MAIN_FIELD_3 = 'mainField3';\nShow.KEY_MAIN_FIELD_4 = 'mainField4';\nShow.KEY_ALIGNMENT = 'alignment';\nShow.KEY_STATUS_BAR = 'statusBar';\nShow.KEY_MEDIA_CLOCK = 'mediaClock';\nShow.KEY_MEDIA_TRACK = 'mediaTrack';\nShow.KEY_GRAPHIC = 'graphic';\nShow.KEY_SECONDARY_GRAPHIC = 'secondaryGraphic';\nShow.KEY_SOFT_BUTTONS = 'softButtons';\nShow.KEY_CUSTOM_PRESETS = 'customPresets';\nShow.KEY_METADATA_TAGS = 'metadataTags';\nShow.KEY_TEMPLATE_TITLE = 'templateTitle';\nShow.KEY_WINDOW_ID = 'windowID';\nShow.KEY_TEMPLATE_CONFIGURATION = 'templateConfiguration';\n\nexport { Show };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ShowResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Show);\n    }\n}\n\n\nexport { ShowResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Speaks a text.\n */\nclass Speak extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Speak);\n    }\n\n    /**\n     * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least\n     *                              one item.\n     * @return {Speak}\n     */\n    setTtsChunks (chunks) {\n        this.validateType(TTSChunk, chunks, true);\n        this.setParameter(Speak.KEY_TTS_CHUNKS, chunks);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getTtsChunks () {\n        return this.getObject(TTSChunk, Speak.KEY_TTS_CHUNKS);\n    }\n}\n\nSpeak.KEY_TTS_CHUNKS = 'ttsChunks';\n\nexport { Speak };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SpeakResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Speak);\n    }\n}\n\n\nexport { SpeakResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass StartTime extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} hours - The hour of the media clock. Some radios only support a max of 19 hours. If out of range,\n     *                         it will be rejected.\n     * @return {StartTime}\n     */\n    setHours (hours) {\n        this.setParameter(StartTime.KEY_HOURS, hours);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHours () {\n        return this.getParameter(StartTime.KEY_HOURS);\n    }\n\n    /**\n     * @param {Number} minutes\n     * @return {StartTime}\n     */\n    setMinutes (minutes) {\n        this.setParameter(StartTime.KEY_MINUTES, minutes);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMinutes () {\n        return this.getParameter(StartTime.KEY_MINUTES);\n    }\n\n    /**\n     * @param {Number} seconds\n     * @return {StartTime}\n     */\n    setSeconds (seconds) {\n        this.setParameter(StartTime.KEY_SECONDS, seconds);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSeconds () {\n        return this.getParameter(StartTime.KEY_SECONDS);\n    }\n}\n\nStartTime.KEY_HOURS = 'hours';\nStartTime.KEY_MINUTES = 'minutes';\nStartTime.KEY_SECONDS = 'seconds';\n\nexport { StartTime };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Describes how the media clock timer should behave on the platform\n * @typedef {Enum} UpdateMode\n * @property {Object} _MAP\n */\nclass UpdateMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Starts the media clock timer counting upwards, as in time elapsed.\n     * @return {String}\n     */\n    static get COUNTUP () {\n        return UpdateMode._MAP.COUNTUP;\n    }\n\n    /**\n     * Starts the media clock timer counting downwards, as in time remaining.\n     * @return {String}\n     */\n    static get COUNTDOWN () {\n        return UpdateMode._MAP.COUNTDOWN;\n    }\n\n    /**\n     * Pauses the media clock timer\n     * @return {String}\n     */\n    static get PAUSE () {\n        return UpdateMode._MAP.PAUSE;\n    }\n\n    /**\n     * Resume the media clock timer\n     * @return {String}\n     */\n    static get RESUME () {\n        return UpdateMode._MAP.RESUME;\n    }\n\n    /**\n     * Clears the media clock timer (previously done through Show->mediaClock)\n     * @return {String}\n     */\n    static get CLEAR () {\n        return UpdateMode._MAP.CLEAR;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return UpdateMode._valueForKey(key, UpdateMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return UpdateMode._keyForValue(value, UpdateMode._MAP);\n    }\n}\n\nUpdateMode._MAP = Object.freeze({\n    'COUNTUP': 'COUNTUP',\n    'COUNTDOWN': 'COUNTDOWN',\n    'PAUSE': 'PAUSE',\n    'RESUME': 'RESUME',\n    'CLEAR': 'CLEAR',\n});\n\nexport { UpdateMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} AudioStreamingIndicator\n * @property {Object} _MAP\n */\nclass AudioStreamingIndicator extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Default playback indicator. By default the playback indicator should be PLAY_PAUSE when: - the media app is\n     * newly registered on the head unit (after RegisterAppInterface) - the media app was closed by the user (App\n     * enters HMI_NONE) - the app sends SetMediaClockTimer with audioStreamingIndicator not set to any value\n     * @return {String}\n     */\n    static get PLAY_PAUSE () {\n        return AudioStreamingIndicator._MAP.PLAY_PAUSE;\n    }\n\n    /**\n     * Indicates that a button press of the Play/Pause button starts the audio playback.\n     * @return {String}\n     */\n    static get PLAY () {\n        return AudioStreamingIndicator._MAP.PLAY;\n    }\n\n    /**\n     * Indicates that a button press of the Play/Pause button pauses the current audio playback.\n     * @return {String}\n     */\n    static get PAUSE () {\n        return AudioStreamingIndicator._MAP.PAUSE;\n    }\n\n    /**\n     * Indicates that a button press of the Play/Pause button stops the current audio playback.\n     * @return {String}\n     */\n    static get STOP () {\n        return AudioStreamingIndicator._MAP.STOP;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return AudioStreamingIndicator._valueForKey(key, AudioStreamingIndicator._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return AudioStreamingIndicator._keyForValue(value, AudioStreamingIndicator._MAP);\n    }\n}\n\nAudioStreamingIndicator._MAP = Object.freeze({\n    'PLAY_PAUSE': 'PLAY_PAUSE',\n    'PLAY': 'PLAY',\n    'PAUSE': 'PAUSE',\n    'STOP': 'STOP',\n});\n\nexport { AudioStreamingIndicator };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { StartTime } from '../structs/StartTime.js';\nimport { UpdateMode } from '../enums/UpdateMode.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { AudioStreamingIndicator } from '../enums/AudioStreamingIndicator.js';\nimport { RpcRequest } from '../RpcRequest.js';\n\n/**\n * Sets the initial media clock value and automatic update method.\n */\nclass SetMediaClockTimer extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetMediaClockTimer);\n    }\n\n    /**\n     * @param {StartTime} time - See StartTime. startTime must be provided for \"COUNTUP\" and \"COUNTDOWN\". startTime will\n     *                           be ignored for \"RESUME\", and \"CLEAR\" startTime can be sent for \"PAUSE\", in which case\n     *                           it will update the paused startTime\n     * @return {SetMediaClockTimer}\n     */\n    setStartTime (time) {\n        this.validateType(StartTime, time);\n        this.setParameter(SetMediaClockTimer.KEY_START_TIME, time);\n        return this;\n    }\n\n    /**\n     * @return {StartTime}\n     */\n    getStartTime () {\n        return this.getObject(StartTime, SetMediaClockTimer.KEY_START_TIME);\n    }\n\n    /**\n     * @param {StartTime} time - See StartTime. endTime can be provided for \"COUNTUP\" and \"COUNTDOWN\"; to be used to\n     *                           calculate any visual progress bar (if not provided, this feature is ignored) If endTime\n     *                           is greater then startTime for COUNTDOWN or less than startTime for COUNTUP, then the\n     *                           request will return an INVALID_DATA. endTime will be ignored for \"RESUME\", and \"CLEAR\"\n     *                           endTime can be sent for \"PAUSE\", in which case it will update the paused endTime\n     * @return {SetMediaClockTimer}\n     */\n    setEndTime (time) {\n        this.validateType(StartTime, time);\n        this.setParameter(SetMediaClockTimer.KEY_END_TIME, time);\n        return this;\n    }\n\n    /**\n     * @return {StartTime}\n     */\n    getEndTime () {\n        return this.getObject(StartTime, SetMediaClockTimer.KEY_END_TIME);\n    }\n\n    /**\n     * @param {UpdateMode} mode - Enumeration to control the media clock. In case of pause, resume, or clear, the start\n     *                            time value is ignored and shall be left out. For resume, the time continues with the\n     *                            same value as it was when paused.\n     * @return {SetMediaClockTimer}\n     */\n    setUpdateMode (mode) {\n        this.validateType(UpdateMode, mode);\n        this.setParameter(SetMediaClockTimer.KEY_UPDATE_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {UpdateMode}\n     */\n    getUpdateMode () {\n        return this.getObject(UpdateMode, SetMediaClockTimer.KEY_UPDATE_MODE);\n    }\n\n    /**\n     * @param {AudioStreamingIndicator} indicator - Enumeration for the indicator icon on a play/pause button. see\n     *                                              AudioStreamingIndicator.\n     * @return {SetMediaClockTimer}\n     */\n    setAudioStreamingIndicator (indicator) {\n        this.validateType(AudioStreamingIndicator, indicator);\n        this.setParameter(SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR, indicator);\n        return this;\n    }\n\n    /**\n     * @return {AudioStreamingIndicator}\n     */\n    getAudioStreamingIndicator () {\n        return this.getObject(AudioStreamingIndicator, SetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR);\n    }\n}\n\nSetMediaClockTimer.KEY_START_TIME = 'startTime';\nSetMediaClockTimer.KEY_END_TIME = 'endTime';\nSetMediaClockTimer.KEY_UPDATE_MODE = 'updateMode';\nSetMediaClockTimer.KEY_AUDIO_STREAMING_INDICATOR = 'audioStreamingIndicator';\n\nexport { SetMediaClockTimer };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SetMediaClockTimerResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetMediaClockTimer);\n    }\n}\n\n\nexport { SetMediaClockTimerResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { AudioType } from '../enums/AudioType.js';\nimport { BitsPerSample } from '../enums/BitsPerSample.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { SamplingRate } from '../enums/SamplingRate.js';\n\n/**\n * Starts audio pass thru session\n */\nclass PerformAudioPassThru extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PerformAudioPassThru);\n    }\n\n    /**\n     * @param {TTSChunk[]} prompt - The module will speak this prompt before opening the audio pass thru session. An\n     *                              array of text chunks of type TTSChunk. See TTSChunk. The array must have at least\n     *                              one item. If omitted, then no initial prompt is spoken.\n     * @return {PerformAudioPassThru}\n     */\n    setInitialPrompt (prompt) {\n        this.validateType(TTSChunk, prompt, true);\n        this.setParameter(PerformAudioPassThru.KEY_INITIAL_PROMPT, prompt);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getInitialPrompt () {\n        return this.getObject(TTSChunk, PerformAudioPassThru.KEY_INITIAL_PROMPT);\n    }\n\n    /**\n     * @param {String} text1 - First line of text displayed during audio capture.\n     * @return {PerformAudioPassThru}\n     */\n    setAudioPassThruDisplayText1 (text1) {\n        this.setParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1, text1);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAudioPassThruDisplayText1 () {\n        return this.getParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1);\n    }\n\n    /**\n     * @param {String} text2 - Second line of text displayed during audio capture.\n     * @return {PerformAudioPassThru}\n     */\n    setAudioPassThruDisplayText2 (text2) {\n        this.setParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2, text2);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAudioPassThruDisplayText2 () {\n        return this.getParameter(PerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2);\n    }\n\n    /**\n     * @param {SamplingRate} rate - This value shall be allowed at 8 kHz or 16 or 22 or 44 kHz.\n     * @return {PerformAudioPassThru}\n     */\n    setSamplingRate (rate) {\n        this.validateType(SamplingRate, rate);\n        this.setParameter(PerformAudioPassThru.KEY_SAMPLING_RATE, rate);\n        return this;\n    }\n\n    /**\n     * @return {SamplingRate}\n     */\n    getSamplingRate () {\n        return this.getObject(SamplingRate, PerformAudioPassThru.KEY_SAMPLING_RATE);\n    }\n\n    /**\n     * @param {Number} duration - The maximum duration of audio recording in milliseconds.\n     * @return {PerformAudioPassThru}\n     */\n    setMaxDuration (duration) {\n        this.setParameter(PerformAudioPassThru.KEY_MAX_DURATION, duration);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaxDuration () {\n        return this.getParameter(PerformAudioPassThru.KEY_MAX_DURATION);\n    }\n\n    /**\n     * @param {BitsPerSample} sample - Specifies the quality the audio is recorded. Currently 8 bit or 16 bit.\n     * @return {PerformAudioPassThru}\n     */\n    setBitsPerSample (sample) {\n        this.validateType(BitsPerSample, sample);\n        this.setParameter(PerformAudioPassThru.KEY_BITS_PER_SAMPLE, sample);\n        return this;\n    }\n\n    /**\n     * @return {BitsPerSample}\n     */\n    getBitsPerSample () {\n        return this.getObject(BitsPerSample, PerformAudioPassThru.KEY_BITS_PER_SAMPLE);\n    }\n\n    /**\n     * @param {AudioType} type - Specifies the type of audio data being requested.\n     * @return {PerformAudioPassThru}\n     */\n    setAudioType (type) {\n        this.validateType(AudioType, type);\n        this.setParameter(PerformAudioPassThru.KEY_AUDIO_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {AudioType}\n     */\n    getAudioType () {\n        return this.getObject(AudioType, PerformAudioPassThru.KEY_AUDIO_TYPE);\n    }\n\n    /**\n     * @param {Boolean} audio - Defines if the current audio source should be muted during the APT session. If not, the\n     *                          audio source will play without interruption. If omitted, the value is set to true.\n     * @return {PerformAudioPassThru}\n     */\n    setMuteAudio (audio) {\n        this.setParameter(PerformAudioPassThru.KEY_MUTE_AUDIO, audio);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMuteAudio () {\n        return this.getParameter(PerformAudioPassThru.KEY_MUTE_AUDIO);\n    }\n}\n\nPerformAudioPassThru.KEY_INITIAL_PROMPT = 'initialPrompt';\nPerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1 = 'audioPassThruDisplayText1';\nPerformAudioPassThru.KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2 = 'audioPassThruDisplayText2';\nPerformAudioPassThru.KEY_SAMPLING_RATE = 'samplingRate';\nPerformAudioPassThru.KEY_MAX_DURATION = 'maxDuration';\nPerformAudioPassThru.KEY_BITS_PER_SAMPLE = 'bitsPerSample';\nPerformAudioPassThru.KEY_AUDIO_TYPE = 'audioType';\nPerformAudioPassThru.KEY_MUTE_AUDIO = 'muteAudio';\n\nexport { PerformAudioPassThru };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass PerformAudioPassThruResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PerformAudioPassThru);\n    }\n}\n\n\nexport { PerformAudioPassThruResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * When this request is invoked, the audio capture stops.\n */\nclass EndAudioPassThru extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.EndAudioPassThru);\n    }\n}\n\n\nexport { EndAudioPassThru };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass EndAudioPassThruResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.EndAudioPassThru);\n    }\n}\n\n\nexport { EndAudioPassThruResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { ButtonName } from '../enums/ButtonName.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Subscribes to built-in HMI buttons. The application will be notified by the OnButtonEvent and OnButtonPress. To\n * unsubscribe the notifications, use unsubscribeButton.\n */\nclass SubscribeButton extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SubscribeButton);\n    }\n\n    /**\n     * @param {ButtonName} name - Name of the button to subscribe.\n     * @return {SubscribeButton}\n     */\n    setButtonName (name) {\n        this.validateType(ButtonName, name);\n        this.setParameter(SubscribeButton.KEY_BUTTON_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {ButtonName}\n     */\n    getButtonName () {\n        return this.getObject(ButtonName, SubscribeButton.KEY_BUTTON_NAME);\n    }\n}\n\nSubscribeButton.KEY_BUTTON_NAME = 'buttonName';\n\nexport { SubscribeButton };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SubscribeButtonResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SubscribeButton);\n    }\n}\n\n\nexport { SubscribeButtonResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { ButtonName } from '../enums/ButtonName.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Unsubscribes from built-in HMI buttons.\n */\nclass UnsubscribeButton extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnsubscribeButton);\n    }\n\n    /**\n     * @param {ButtonName} name - Name of the button to unsubscribe.\n     * @return {UnsubscribeButton}\n     */\n    setButtonName (name) {\n        this.validateType(ButtonName, name);\n        this.setParameter(UnsubscribeButton.KEY_BUTTON_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {ButtonName}\n     */\n    getButtonName () {\n        return this.getObject(ButtonName, UnsubscribeButton.KEY_BUTTON_NAME);\n    }\n}\n\nUnsubscribeButton.KEY_BUTTON_NAME = 'buttonName';\n\nexport { UnsubscribeButton };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass UnsubscribeButtonResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnsubscribeButton);\n    }\n}\n\n\nexport { UnsubscribeButtonResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Subscribes for specific published data items. The data will be only sent if it has changed. The application will be\n * notified by the onVehicleData notification whenever new data is available. To unsubscribe the notifications, use\n * unsubscribe with the same subscriptionType.\n */\nclass SubscribeVehicleData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SubscribeVehicleData);\n    }\n\n    /**\n     * @param {Boolean} gps - See GPSData\n     * @return {SubscribeVehicleData}\n     */\n    setGps (gps) {\n        this.setParameter(SubscribeVehicleData.KEY_GPS, gps);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getGps () {\n        return this.getParameter(SubscribeVehicleData.KEY_GPS);\n    }\n\n    /**\n     * @param {Boolean} speed - The vehicle speed in kilometers per hour\n     * @return {SubscribeVehicleData}\n     */\n    setSpeed (speed) {\n        this.setParameter(SubscribeVehicleData.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSpeed () {\n        return this.getParameter(SubscribeVehicleData.KEY_SPEED);\n    }\n\n    /**\n     * @param {Boolean} rpm - The number of revolutions per minute of the engine\n     * @return {SubscribeVehicleData}\n     */\n    setRpm (rpm) {\n        this.setParameter(SubscribeVehicleData.KEY_RPM, rpm);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRpm () {\n        return this.getParameter(SubscribeVehicleData.KEY_RPM);\n    }\n\n    /**\n     * @param {Boolean} level - The fuel level in the tank (percentage)\n     * @return {SubscribeVehicleData}\n     */\n    setFuelLevel (level) {\n        this.setParameter(SubscribeVehicleData.KEY_FUEL_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelLevel () {\n        return this.getParameter(SubscribeVehicleData.KEY_FUEL_LEVEL);\n    }\n\n    /**\n     * @param {Boolean} level_state - The fuel level state\n     * @return {SubscribeVehicleData}\n     */\n    setFuelLevel_State (level_state) {\n        this.setParameter(SubscribeVehicleData.KEY_FUEL_LEVEL_STATE, level_state);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelLevel_State () {\n        return this.getParameter(SubscribeVehicleData.KEY_FUEL_LEVEL_STATE);\n    }\n\n    /**\n     * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres\n     * @return {SubscribeVehicleData}\n     */\n    setInstantFuelConsumption (consumption) {\n        this.setParameter(SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getInstantFuelConsumption () {\n        return this.getParameter(SubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION);\n    }\n\n    /**\n     * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption\n     * @return {SubscribeVehicleData}\n     */\n    setFuelRange (range) {\n        this.setParameter(SubscribeVehicleData.KEY_FUEL_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelRange () {\n        return this.getParameter(SubscribeVehicleData.KEY_FUEL_RANGE);\n    }\n\n    /**\n     * @param {Boolean} temperature - The external temperature in degrees celsius\n     * @return {SubscribeVehicleData}\n     */\n    setExternalTemperature (temperature) {\n        this.setParameter(SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getExternalTemperature () {\n        return this.getParameter(SubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE);\n    }\n\n    /**\n     * @param {Boolean} signal - See TurnSignal\n     * @return {SubscribeVehicleData}\n     */\n    setTurnSignal (signal) {\n        this.setParameter(SubscribeVehicleData.KEY_TURN_SIGNAL, signal);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTurnSignal () {\n        return this.getParameter(SubscribeVehicleData.KEY_TURN_SIGNAL);\n    }\n\n    /**\n     * @param {Boolean} prndl - See PRNDL\n     * @return {SubscribeVehicleData}\n     */\n    setPrndl (prndl) {\n        this.setParameter(SubscribeVehicleData.KEY_PRNDL, prndl);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPrndl () {\n        return this.getParameter(SubscribeVehicleData.KEY_PRNDL);\n    }\n\n    /**\n     * @param {Boolean} pressure - See TireStatus\n     * @return {SubscribeVehicleData}\n     */\n    setTirePressure (pressure) {\n        this.setParameter(SubscribeVehicleData.KEY_TIRE_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTirePressure () {\n        return this.getParameter(SubscribeVehicleData.KEY_TIRE_PRESSURE);\n    }\n\n    /**\n     * @param {Boolean} odometer - Odometer in km\n     * @return {SubscribeVehicleData}\n     */\n    setOdometer (odometer) {\n        this.setParameter(SubscribeVehicleData.KEY_ODOMETER, odometer);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getOdometer () {\n        return this.getParameter(SubscribeVehicleData.KEY_ODOMETER);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the seat belts\n     * @return {SubscribeVehicleData}\n     */\n    setBeltStatus (status) {\n        this.setParameter(SubscribeVehicleData.KEY_BELT_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBeltStatus () {\n        return this.getParameter(SubscribeVehicleData.KEY_BELT_STATUS);\n    }\n\n    /**\n     * @param {Boolean} information - The body information including power modes\n     * @return {SubscribeVehicleData}\n     */\n    setBodyInformation (information) {\n        this.setParameter(SubscribeVehicleData.KEY_BODY_INFORMATION, information);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBodyInformation () {\n        return this.getParameter(SubscribeVehicleData.KEY_BODY_INFORMATION);\n    }\n\n    /**\n     * @param {Boolean} status - The device status including signal and battery strength\n     * @return {SubscribeVehicleData}\n     */\n    setDeviceStatus (status) {\n        this.setParameter(SubscribeVehicleData.KEY_DEVICE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDeviceStatus () {\n        return this.getParameter(SubscribeVehicleData.KEY_DEVICE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} braking - The status of the brake pedal\n     * @return {SubscribeVehicleData}\n     */\n    setDriverBraking (braking) {\n        this.setParameter(SubscribeVehicleData.KEY_DRIVER_BRAKING, braking);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDriverBraking () {\n        return this.getParameter(SubscribeVehicleData.KEY_DRIVER_BRAKING);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the wipers\n     * @return {SubscribeVehicleData}\n     */\n    setWiperStatus (status) {\n        this.setParameter(SubscribeVehicleData.KEY_WIPER_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getWiperStatus () {\n        return this.getParameter(SubscribeVehicleData.KEY_WIPER_STATUS);\n    }\n\n    /**\n     * @param {Boolean} status - Status of the head lamps\n     * @return {SubscribeVehicleData}\n     */\n    setHeadLampStatus (status) {\n        this.setParameter(SubscribeVehicleData.KEY_HEAD_LAMP_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeadLampStatus () {\n        return this.getParameter(SubscribeVehicleData.KEY_HEAD_LAMP_STATUS);\n    }\n\n    /**\n     * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants\n     * @return {SubscribeVehicleData}\n     */\n    setEngineTorque (torque) {\n        this.setParameter(SubscribeVehicleData.KEY_ENGINE_TORQUE, torque);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEngineTorque () {\n        return this.getParameter(SubscribeVehicleData.KEY_ENGINE_TORQUE);\n    }\n\n    /**\n     * @param {Boolean} position - Accelerator pedal position (percentage depressed)\n     * @return {SubscribeVehicleData}\n     */\n    setAccPedalPosition (position) {\n        this.setParameter(SubscribeVehicleData.KEY_ACC_PEDAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAccPedalPosition () {\n        return this.getParameter(SubscribeVehicleData.KEY_ACC_PEDAL_POSITION);\n    }\n\n    /**\n     * @param {Boolean} angle - Current angle of the steering wheel (in deg)\n     * @return {SubscribeVehicleData}\n     */\n    setSteeringWheelAngle (angle) {\n        this.setParameter(SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSteeringWheelAngle () {\n        return this.getParameter(SubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE);\n    }\n\n    /**\n     * @param {Boolean} life - The estimated percentage of remaining oil life of the engine.\n     * @return {SubscribeVehicleData}\n     */\n    setEngineOilLife (life) {\n        this.setParameter(SubscribeVehicleData.KEY_ENGINE_OIL_LIFE, life);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEngineOilLife () {\n        return this.getParameter(SubscribeVehicleData.KEY_ENGINE_OIL_LIFE);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system.\n     * @return {SubscribeVehicleData}\n     */\n    setElectronicParkBrakeStatus (status) {\n        this.setParameter(SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getElectronicParkBrakeStatus () {\n        return this.getParameter(SubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} id - Parameter used by cloud apps to identify a head unit\n     * @return {SubscribeVehicleData}\n     */\n    setCloudAppVehicleID (id) {\n        this.setParameter(SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCloudAppVehicleID () {\n        return this.getParameter(SubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID);\n    }\n\n    /**\n     * @param {Boolean} info - Emergency Call notification and confirmation data\n     * @return {SubscribeVehicleData}\n     */\n    setECallInfo (info) {\n        this.setParameter(SubscribeVehicleData.KEY_E_CALL_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getECallInfo () {\n        return this.getParameter(SubscribeVehicleData.KEY_E_CALL_INFO);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the air bags\n     * @return {SubscribeVehicleData}\n     */\n    setAirbagStatus (status) {\n        this.setParameter(SubscribeVehicleData.KEY_AIRBAG_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAirbagStatus () {\n        return this.getParameter(SubscribeVehicleData.KEY_AIRBAG_STATUS);\n    }\n\n    /**\n     * @param {Boolean} event - Information related to an emergency event (and if it occurred)\n     * @return {SubscribeVehicleData}\n     */\n    setEmergencyEvent (event) {\n        this.setParameter(SubscribeVehicleData.KEY_EMERGENCY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEmergencyEvent () {\n        return this.getParameter(SubscribeVehicleData.KEY_EMERGENCY_EVENT);\n    }\n\n    /**\n     * @param {Boolean} status - The status modes of the cluster\n     * @return {SubscribeVehicleData}\n     */\n    setClusterModeStatus (status) {\n        this.setParameter(SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getClusterModeStatus () {\n        return this.getParameter(SubscribeVehicleData.KEY_CLUSTER_MODE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} key - Information related to the MyKey feature\n     * @return {SubscribeVehicleData}\n     */\n    setMyKey (key) {\n        this.setParameter(SubscribeVehicleData.KEY_MY_KEY, key);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMyKey () {\n        return this.getParameter(SubscribeVehicleData.KEY_MY_KEY);\n    }\n}\n\nSubscribeVehicleData.KEY_GPS = 'gps';\nSubscribeVehicleData.KEY_SPEED = 'speed';\nSubscribeVehicleData.KEY_RPM = 'rpm';\nSubscribeVehicleData.KEY_FUEL_LEVEL = 'fuelLevel';\nSubscribeVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State';\nSubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption';\nSubscribeVehicleData.KEY_FUEL_RANGE = 'fuelRange';\nSubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature';\nSubscribeVehicleData.KEY_TURN_SIGNAL = 'turnSignal';\nSubscribeVehicleData.KEY_PRNDL = 'prndl';\nSubscribeVehicleData.KEY_TIRE_PRESSURE = 'tirePressure';\nSubscribeVehicleData.KEY_ODOMETER = 'odometer';\nSubscribeVehicleData.KEY_BELT_STATUS = 'beltStatus';\nSubscribeVehicleData.KEY_BODY_INFORMATION = 'bodyInformation';\nSubscribeVehicleData.KEY_DEVICE_STATUS = 'deviceStatus';\nSubscribeVehicleData.KEY_DRIVER_BRAKING = 'driverBraking';\nSubscribeVehicleData.KEY_WIPER_STATUS = 'wiperStatus';\nSubscribeVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus';\nSubscribeVehicleData.KEY_ENGINE_TORQUE = 'engineTorque';\nSubscribeVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition';\nSubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle';\nSubscribeVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife';\nSubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus';\nSubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID';\nSubscribeVehicleData.KEY_E_CALL_INFO = 'eCallInfo';\nSubscribeVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus';\nSubscribeVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent';\nSubscribeVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus';\nSubscribeVehicleData.KEY_MY_KEY = 'myKey';\n\nexport { SubscribeVehicleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes possible result codes of a vehicle data entry request.\n * @typedef {Enum} VehicleDataResultCode\n * @property {Object} _MAP\n */\nclass VehicleDataResultCode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Individual vehicle data item / DTC / DID request or subscription successful\n     * @return {String}\n     */\n    static get VDRC_SUCCESS () {\n        return VehicleDataResultCode._MAP.VDRC_SUCCESS;\n    }\n\n    /**\n     * DTC / DID request successful, however, not all active DTCs or full contents of DID location available\n     * @return {String}\n     */\n    static get VDRC_TRUNCATED_DATA () {\n        return VehicleDataResultCode._MAP.VDRC_TRUNCATED_DATA;\n    }\n\n    /**\n     * This vehicle data item is not allowed for this app by the OEM/Manufactorer of the connected module.\n     * @return {String}\n     */\n    static get VDRC_DISALLOWED () {\n        return VehicleDataResultCode._MAP.VDRC_DISALLOWED;\n    }\n\n    /**\n     * The user has not granted access to this type of vehicle data item at this time.\n     * @return {String}\n     */\n    static get VDRC_USER_DISALLOWED () {\n        return VehicleDataResultCode._MAP.VDRC_USER_DISALLOWED;\n    }\n\n    /**\n     * The ECU ID referenced is not a valid ID on the bus / system.\n     * @return {String}\n     */\n    static get VDRC_INVALID_ID () {\n        return VehicleDataResultCode._MAP.VDRC_INVALID_ID;\n    }\n\n    /**\n     * The requested vehicle data item / DTC / DID is not currently available or responding on the bus / system.\n     * @return {String}\n     */\n    static get VDRC_DATA_NOT_AVAILABLE () {\n        return VehicleDataResultCode._MAP.VDRC_DATA_NOT_AVAILABLE;\n    }\n\n    /**\n     * The vehicle data item is already subscribed.\n     * @return {String}\n     */\n    static get VDRC_DATA_ALREADY_SUBSCRIBED () {\n        return VehicleDataResultCode._MAP.VDRC_DATA_ALREADY_SUBSCRIBED;\n    }\n\n    /**\n     * The vehicle data item cannot be unsubscribed because it is not currently subscribed.\n     * @return {String}\n     */\n    static get VDRC_DATA_NOT_SUBSCRIBED () {\n        return VehicleDataResultCode._MAP.VDRC_DATA_NOT_SUBSCRIBED;\n    }\n\n    /**\n     * The request for this item is ignored because it is already in progress.\n     * @return {String}\n     */\n    static get VDRC_IGNORED () {\n        return VehicleDataResultCode._MAP.VDRC_IGNORED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VehicleDataResultCode._valueForKey(key, VehicleDataResultCode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VehicleDataResultCode._keyForValue(value, VehicleDataResultCode._MAP);\n    }\n}\n\nVehicleDataResultCode._MAP = Object.freeze({\n    'VDRC_SUCCESS': 'SUCCESS',\n    'VDRC_TRUNCATED_DATA': 'TRUNCATED_DATA',\n    'VDRC_DISALLOWED': 'DISALLOWED',\n    'VDRC_USER_DISALLOWED': 'USER_DISALLOWED',\n    'VDRC_INVALID_ID': 'INVALID_ID',\n    'VDRC_DATA_NOT_AVAILABLE': 'VEHICLE_DATA_NOT_AVAILABLE',\n    'VDRC_DATA_ALREADY_SUBSCRIBED': 'DATA_ALREADY_SUBSCRIBED',\n    'VDRC_DATA_NOT_SUBSCRIBED': 'DATA_NOT_SUBSCRIBED',\n    'VDRC_IGNORED': 'IGNORED',\n});\n\nexport { VehicleDataResultCode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Defines the data types that can be published and subscribed to.\n * @typedef {Enum} VehicleDataType\n * @property {Object} _MAP\n */\nclass VehicleDataType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Notifies GPSData may be subscribed\n     * @return {String}\n     */\n    static get VEHICLEDATA_GPS () {\n        return VehicleDataType._MAP.VEHICLEDATA_GPS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_SPEED () {\n        return VehicleDataType._MAP.VEHICLEDATA_SPEED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_RPM () {\n        return VehicleDataType._MAP.VEHICLEDATA_RPM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_FUELLEVEL () {\n        return VehicleDataType._MAP.VEHICLEDATA_FUELLEVEL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_FUELLEVEL_STATE () {\n        return VehicleDataType._MAP.VEHICLEDATA_FUELLEVEL_STATE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_FUELCONSUMPTION () {\n        return VehicleDataType._MAP.VEHICLEDATA_FUELCONSUMPTION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_EXTERNTEMP () {\n        return VehicleDataType._MAP.VEHICLEDATA_EXTERNTEMP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_VIN () {\n        return VehicleDataType._MAP.VEHICLEDATA_VIN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_PRNDL () {\n        return VehicleDataType._MAP.VEHICLEDATA_PRNDL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_TIREPRESSURE () {\n        return VehicleDataType._MAP.VEHICLEDATA_TIREPRESSURE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_ODOMETER () {\n        return VehicleDataType._MAP.VEHICLEDATA_ODOMETER;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_BELTSTATUS () {\n        return VehicleDataType._MAP.VEHICLEDATA_BELTSTATUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_BODYINFO () {\n        return VehicleDataType._MAP.VEHICLEDATA_BODYINFO;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_DEVICESTATUS () {\n        return VehicleDataType._MAP.VEHICLEDATA_DEVICESTATUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_ECALLINFO () {\n        return VehicleDataType._MAP.VEHICLEDATA_ECALLINFO;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_AIRBAGSTATUS () {\n        return VehicleDataType._MAP.VEHICLEDATA_AIRBAGSTATUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_EMERGENCYEVENT () {\n        return VehicleDataType._MAP.VEHICLEDATA_EMERGENCYEVENT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_CLUSTERMODESTATUS () {\n        return VehicleDataType._MAP.VEHICLEDATA_CLUSTERMODESTATUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_MYKEY () {\n        return VehicleDataType._MAP.VEHICLEDATA_MYKEY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_BRAKING () {\n        return VehicleDataType._MAP.VEHICLEDATA_BRAKING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_WIPERSTATUS () {\n        return VehicleDataType._MAP.VEHICLEDATA_WIPERSTATUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_HEADLAMPSTATUS () {\n        return VehicleDataType._MAP.VEHICLEDATA_HEADLAMPSTATUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_BATTVOLTAGE () {\n        return VehicleDataType._MAP.VEHICLEDATA_BATTVOLTAGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_ENGINETORQUE () {\n        return VehicleDataType._MAP.VEHICLEDATA_ENGINETORQUE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_ACCPEDAL () {\n        return VehicleDataType._MAP.VEHICLEDATA_ACCPEDAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_STEERINGWHEEL () {\n        return VehicleDataType._MAP.VEHICLEDATA_STEERINGWHEEL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_TURNSIGNAL () {\n        return VehicleDataType._MAP.VEHICLEDATA_TURNSIGNAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_FUELRANGE () {\n        return VehicleDataType._MAP.VEHICLEDATA_FUELRANGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_ENGINEOILLIFE () {\n        return VehicleDataType._MAP.VEHICLEDATA_ENGINEOILLIFE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_ELECTRONICPARKBRAKESTATUS () {\n        return VehicleDataType._MAP.VEHICLEDATA_ELECTRONICPARKBRAKESTATUS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_CLOUDAPPVEHICLEID () {\n        return VehicleDataType._MAP.VEHICLEDATA_CLOUDAPPVEHICLEID;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLEDATA_OEM_CUSTOM_DATA () {\n        return VehicleDataType._MAP.VEHICLEDATA_OEM_CUSTOM_DATA;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VehicleDataType._valueForKey(key, VehicleDataType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VehicleDataType._keyForValue(value, VehicleDataType._MAP);\n    }\n}\n\nVehicleDataType._MAP = Object.freeze({\n    'VEHICLEDATA_GPS': 'VEHICLEDATA_GPS',\n    'VEHICLEDATA_SPEED': 'VEHICLEDATA_SPEED',\n    'VEHICLEDATA_RPM': 'VEHICLEDATA_RPM',\n    'VEHICLEDATA_FUELLEVEL': 'VEHICLEDATA_FUELLEVEL',\n    'VEHICLEDATA_FUELLEVEL_STATE': 'VEHICLEDATA_FUELLEVEL_STATE',\n    'VEHICLEDATA_FUELCONSUMPTION': 'VEHICLEDATA_FUELCONSUMPTION',\n    'VEHICLEDATA_EXTERNTEMP': 'VEHICLEDATA_EXTERNTEMP',\n    'VEHICLEDATA_VIN': 'VEHICLEDATA_VIN',\n    'VEHICLEDATA_PRNDL': 'VEHICLEDATA_PRNDL',\n    'VEHICLEDATA_TIREPRESSURE': 'VEHICLEDATA_TIREPRESSURE',\n    'VEHICLEDATA_ODOMETER': 'VEHICLEDATA_ODOMETER',\n    'VEHICLEDATA_BELTSTATUS': 'VEHICLEDATA_BELTSTATUS',\n    'VEHICLEDATA_BODYINFO': 'VEHICLEDATA_BODYINFO',\n    'VEHICLEDATA_DEVICESTATUS': 'VEHICLEDATA_DEVICESTATUS',\n    'VEHICLEDATA_ECALLINFO': 'VEHICLEDATA_ECALLINFO',\n    'VEHICLEDATA_AIRBAGSTATUS': 'VEHICLEDATA_AIRBAGSTATUS',\n    'VEHICLEDATA_EMERGENCYEVENT': 'VEHICLEDATA_EMERGENCYEVENT',\n    'VEHICLEDATA_CLUSTERMODESTATUS': 'VEHICLEDATA_CLUSTERMODESTATUS',\n    'VEHICLEDATA_MYKEY': 'VEHICLEDATA_MYKEY',\n    'VEHICLEDATA_BRAKING': 'VEHICLEDATA_BRAKING',\n    'VEHICLEDATA_WIPERSTATUS': 'VEHICLEDATA_WIPERSTATUS',\n    'VEHICLEDATA_HEADLAMPSTATUS': 'VEHICLEDATA_HEADLAMPSTATUS',\n    'VEHICLEDATA_BATTVOLTAGE': 'VEHICLEDATA_BATTVOLTAGE',\n    'VEHICLEDATA_ENGINETORQUE': 'VEHICLEDATA_ENGINETORQUE',\n    'VEHICLEDATA_ACCPEDAL': 'VEHICLEDATA_ACCPEDAL',\n    'VEHICLEDATA_STEERINGWHEEL': 'VEHICLEDATA_STEERINGWHEEL',\n    'VEHICLEDATA_TURNSIGNAL': 'VEHICLEDATA_TURNSIGNAL',\n    'VEHICLEDATA_FUELRANGE': 'VEHICLEDATA_FUELRANGE',\n    'VEHICLEDATA_ENGINEOILLIFE': 'VEHICLEDATA_ENGINEOILLIFE',\n    'VEHICLEDATA_ELECTRONICPARKBRAKESTATUS': 'VEHICLEDATA_ELECTRONICPARKBRAKESTATUS',\n    'VEHICLEDATA_CLOUDAPPVEHICLEID': 'VEHICLEDATA_CLOUDAPPVEHICLEID',\n    'VEHICLEDATA_OEM_CUSTOM_DATA': 'VEHICLEDATA_OEM_CUSTOM_DATA',\n});\n\nexport { VehicleDataType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VehicleDataResultCode } from '../enums/VehicleDataResultCode.js';\nimport { VehicleDataType } from '../enums/VehicleDataType.js';\n\n/**\n * Individual published data request result\n */\nclass VehicleDataResult extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {VehicleDataType} type - Defined published data element type.\n     * @return {VehicleDataResult}\n     */\n    setDataType (type) {\n        this.validateType(VehicleDataType, type);\n        this.setParameter(VehicleDataResult.KEY_DATA_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataType}\n     */\n    getDataType () {\n        return this.getObject(VehicleDataType, VehicleDataResult.KEY_DATA_TYPE);\n    }\n\n    /**\n     * @param {VehicleDataResultCode} code - Published data result code.\n     * @return {VehicleDataResult}\n     */\n    setResultCode (code) {\n        this.validateType(VehicleDataResultCode, code);\n        this.setParameter(VehicleDataResult.KEY_RESULT_CODE, code);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResultCode}\n     */\n    getResultCode () {\n        return this.getObject(VehicleDataResultCode, VehicleDataResult.KEY_RESULT_CODE);\n    }\n\n    /**\n     * @param {String} type - Type of requested oem specific parameter\n     * @return {VehicleDataResult}\n     */\n    setOemCustomDataType (type) {\n        this.setParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getOemCustomDataType () {\n        return this.getParameter(VehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE);\n    }\n}\n\nVehicleDataResult.KEY_DATA_TYPE = 'dataType';\nVehicleDataResult.KEY_RESULT_CODE = 'resultCode';\nVehicleDataResult.KEY_OEM_CUSTOM_DATA_TYPE = 'oemCustomDataType';\n\nexport { VehicleDataResult };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\nimport { VehicleDataResult } from '../structs/VehicleDataResult.js';\n\nclass SubscribeVehicleDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SubscribeVehicleData);\n    }\n\n    /**\n     * @param {VehicleDataResult} gps - See GPSData\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setGps (gps) {\n        this.validateType(VehicleDataResult, gps);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_GPS, gps);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getGps () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_GPS);\n    }\n\n    /**\n     * @param {VehicleDataResult} speed - The vehicle speed in kilometers per hour\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setSpeed (speed) {\n        this.validateType(VehicleDataResult, speed);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getSpeed () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_SPEED);\n    }\n\n    /**\n     * @param {VehicleDataResult} rpm - The number of revolutions per minute of the engine\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setRpm (rpm) {\n        this.validateType(VehicleDataResult, rpm);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_RPM, rpm);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getRpm () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_RPM);\n    }\n\n    /**\n     * @param {VehicleDataResult} level - The fuel level in the tank (percentage)\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setFuelLevel (level) {\n        this.validateType(VehicleDataResult, level);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getFuelLevel () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_LEVEL);\n    }\n\n    /**\n     * @param {VehicleDataResult} level_state - The fuel level state\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setFuelLevel_State (level_state) {\n        this.validateType(VehicleDataResult, level_state);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getFuelLevel_State () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE);\n    }\n\n    /**\n     * @param {VehicleDataResult} consumption - The instantaneous fuel consumption in microlitres\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setInstantFuelConsumption (consumption) {\n        this.validateType(VehicleDataResult, consumption);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getInstantFuelConsumption () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION);\n    }\n\n    /**\n     * @param {VehicleDataResult} range - The estimate range in KM the vehicle can travel based on fuel level and\n     *                                    consumption\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setFuelRange (range) {\n        this.validateType(VehicleDataResult, range);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_FUEL_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getFuelRange () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_FUEL_RANGE);\n    }\n\n    /**\n     * @param {VehicleDataResult} temperature - The external temperature in degrees celsius.\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setExternalTemperature (temperature) {\n        this.validateType(VehicleDataResult, temperature);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getExternalTemperature () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE);\n    }\n\n    /**\n     * @param {VehicleDataResult} signal - See TurnSignal\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setTurnSignal (signal) {\n        this.validateType(VehicleDataResult, signal);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_TURN_SIGNAL, signal);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getTurnSignal () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_TURN_SIGNAL);\n    }\n\n    /**\n     * @param {VehicleDataResult} prndl - See PRNDL\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setPrndl (prndl) {\n        this.validateType(VehicleDataResult, prndl);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_PRNDL, prndl);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getPrndl () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_PRNDL);\n    }\n\n    /**\n     * @param {VehicleDataResult} pressure - See TireStatus\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setTirePressure (pressure) {\n        this.validateType(VehicleDataResult, pressure);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getTirePressure () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_TIRE_PRESSURE);\n    }\n\n    /**\n     * @param {VehicleDataResult} odometer - Odometer in km\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setOdometer (odometer) {\n        this.validateType(VehicleDataResult, odometer);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_ODOMETER, odometer);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getOdometer () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ODOMETER);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the seat belts\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setBeltStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_BELT_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getBeltStatus () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_BELT_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} information - The body information including power modes\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setBodyInformation (information) {\n        this.validateType(VehicleDataResult, information);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_BODY_INFORMATION, information);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getBodyInformation () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_BODY_INFORMATION);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The device status including signal and battery strength\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setDeviceStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_DEVICE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getDeviceStatus () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_DEVICE_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} braking - The status of the brake pedal\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setDriverBraking (braking) {\n        this.validateType(VehicleDataResult, braking);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING, braking);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getDriverBraking () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_DRIVER_BRAKING);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the wipers\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setWiperStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_WIPER_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getWiperStatus () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_WIPER_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - Status of the head lamps\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setHeadLampStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getHeadLampStatus () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} torque - Torque value for engine (in Nm) on non-diesel variants\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setEngineTorque (torque) {\n        this.validateType(VehicleDataResult, torque);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE, torque);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getEngineTorque () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ENGINE_TORQUE);\n    }\n\n    /**\n     * @param {VehicleDataResult} position - Accelerator pedal position (percentage depressed)\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setAccPedalPosition (position) {\n        this.validateType(VehicleDataResult, position);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getAccPedalPosition () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION);\n    }\n\n    /**\n     * @param {VehicleDataResult} angle - Current angle of the steering wheel (in deg)\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setSteeringWheelAngle (angle) {\n        this.validateType(VehicleDataResult, angle);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getSteeringWheelAngle () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE);\n    }\n\n    /**\n     * @param {VehicleDataResult} life - The estimated percentage of remaining oil life of the engine.\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setEngineOilLife (life) {\n        this.validateType(VehicleDataResult, life);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getEngineOilLife () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the park brake as provided by Electric Park Brake (EPB) system.\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setElectronicParkBrakeStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getElectronicParkBrakeStatus () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} id - Parameter used by cloud apps to identify a head unit\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setCloudAppVehicleID (id) {\n        this.validateType(VehicleDataResult, id);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getCloudAppVehicleID () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID);\n    }\n\n    /**\n     * @param {VehicleDataResult} info - Emergency Call notification and confirmation data\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setECallInfo (info) {\n        this.validateType(VehicleDataResult, info);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_E_CALL_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getECallInfo () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_E_CALL_INFO);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the air bags\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setAirbagStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getAirbagStatus () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_AIRBAG_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} event - Information related to an emergency event (and if it occurred)\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setEmergencyEvent (event) {\n        this.validateType(VehicleDataResult, event);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getEmergencyEvent () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT);\n    }\n\n    /**\n     * @param {VehicleDataResult} modes - The status modes of the cluster\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setClusterModes (modes) {\n        this.validateType(VehicleDataResult, modes);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_CLUSTER_MODES, modes);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getClusterModes () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_CLUSTER_MODES);\n    }\n\n    /**\n     * @param {VehicleDataResult} key - Information related to the MyKey feature\n     * @return {SubscribeVehicleDataResponse}\n     */\n    setMyKey (key) {\n        this.validateType(VehicleDataResult, key);\n        this.setParameter(SubscribeVehicleDataResponse.KEY_MY_KEY, key);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getMyKey () {\n        return this.getObject(VehicleDataResult, SubscribeVehicleDataResponse.KEY_MY_KEY);\n    }\n}\n\nSubscribeVehicleDataResponse.KEY_GPS = 'gps';\nSubscribeVehicleDataResponse.KEY_SPEED = 'speed';\nSubscribeVehicleDataResponse.KEY_RPM = 'rpm';\nSubscribeVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel';\nSubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State';\nSubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption';\nSubscribeVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange';\nSubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature';\nSubscribeVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal';\nSubscribeVehicleDataResponse.KEY_PRNDL = 'prndl';\nSubscribeVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure';\nSubscribeVehicleDataResponse.KEY_ODOMETER = 'odometer';\nSubscribeVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus';\nSubscribeVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation';\nSubscribeVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus';\nSubscribeVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking';\nSubscribeVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus';\nSubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus';\nSubscribeVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque';\nSubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition';\nSubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle';\nSubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife';\nSubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus';\nSubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID';\nSubscribeVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo';\nSubscribeVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus';\nSubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent';\nSubscribeVehicleDataResponse.KEY_CLUSTER_MODES = 'clusterModes';\nSubscribeVehicleDataResponse.KEY_MY_KEY = 'myKey';\n\nexport { SubscribeVehicleDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * This function is used to unsubscribe the notifications from the subscribeVehicleData function.\n */\nclass UnsubscribeVehicleData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnsubscribeVehicleData);\n    }\n\n    /**\n     * @param {Boolean} gps - See GPSData\n     * @return {UnsubscribeVehicleData}\n     */\n    setGps (gps) {\n        this.setParameter(UnsubscribeVehicleData.KEY_GPS, gps);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getGps () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_GPS);\n    }\n\n    /**\n     * @param {Boolean} speed - The vehicle speed in kilometers per hour\n     * @return {UnsubscribeVehicleData}\n     */\n    setSpeed (speed) {\n        this.setParameter(UnsubscribeVehicleData.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSpeed () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_SPEED);\n    }\n\n    /**\n     * @param {Boolean} rpm - The number of revolutions per minute of the engine\n     * @return {UnsubscribeVehicleData}\n     */\n    setRpm (rpm) {\n        this.setParameter(UnsubscribeVehicleData.KEY_RPM, rpm);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRpm () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_RPM);\n    }\n\n    /**\n     * @param {Boolean} level - The fuel level in the tank (percentage)\n     * @return {UnsubscribeVehicleData}\n     */\n    setFuelLevel (level) {\n        this.setParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelLevel () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL);\n    }\n\n    /**\n     * @param {Boolean} level_state - The fuel level state\n     * @return {UnsubscribeVehicleData}\n     */\n    setFuelLevel_State (level_state) {\n        this.setParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE, level_state);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelLevel_State () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE);\n    }\n\n    /**\n     * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres\n     * @return {UnsubscribeVehicleData}\n     */\n    setInstantFuelConsumption (consumption) {\n        this.setParameter(UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getInstantFuelConsumption () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION);\n    }\n\n    /**\n     * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption\n     * @return {UnsubscribeVehicleData}\n     */\n    setFuelRange (range) {\n        this.setParameter(UnsubscribeVehicleData.KEY_FUEL_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelRange () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_FUEL_RANGE);\n    }\n\n    /**\n     * @param {Boolean} temperature - The external temperature in degrees celsius.\n     * @return {UnsubscribeVehicleData}\n     */\n    setExternalTemperature (temperature) {\n        this.setParameter(UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getExternalTemperature () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE);\n    }\n\n    /**\n     * @param {Boolean} signal - See TurnSignal\n     * @return {UnsubscribeVehicleData}\n     */\n    setTurnSignal (signal) {\n        this.setParameter(UnsubscribeVehicleData.KEY_TURN_SIGNAL, signal);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTurnSignal () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_TURN_SIGNAL);\n    }\n\n    /**\n     * @param {Boolean} prndl - See PRNDL\n     * @return {UnsubscribeVehicleData}\n     */\n    setPrndl (prndl) {\n        this.setParameter(UnsubscribeVehicleData.KEY_PRNDL, prndl);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPrndl () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_PRNDL);\n    }\n\n    /**\n     * @param {Boolean} pressure - See TireStatus\n     * @return {UnsubscribeVehicleData}\n     */\n    setTirePressure (pressure) {\n        this.setParameter(UnsubscribeVehicleData.KEY_TIRE_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTirePressure () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_TIRE_PRESSURE);\n    }\n\n    /**\n     * @param {Boolean} odometer - Odometer in km\n     * @return {UnsubscribeVehicleData}\n     */\n    setOdometer (odometer) {\n        this.setParameter(UnsubscribeVehicleData.KEY_ODOMETER, odometer);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getOdometer () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_ODOMETER);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the seat belts\n     * @return {UnsubscribeVehicleData}\n     */\n    setBeltStatus (status) {\n        this.setParameter(UnsubscribeVehicleData.KEY_BELT_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBeltStatus () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_BELT_STATUS);\n    }\n\n    /**\n     * @param {Boolean} information - The body information including power modes\n     * @return {UnsubscribeVehicleData}\n     */\n    setBodyInformation (information) {\n        this.setParameter(UnsubscribeVehicleData.KEY_BODY_INFORMATION, information);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBodyInformation () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_BODY_INFORMATION);\n    }\n\n    /**\n     * @param {Boolean} status - The device status including signal and battery strength\n     * @return {UnsubscribeVehicleData}\n     */\n    setDeviceStatus (status) {\n        this.setParameter(UnsubscribeVehicleData.KEY_DEVICE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDeviceStatus () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_DEVICE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} braking - The status of the brake pedal\n     * @return {UnsubscribeVehicleData}\n     */\n    setDriverBraking (braking) {\n        this.setParameter(UnsubscribeVehicleData.KEY_DRIVER_BRAKING, braking);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDriverBraking () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_DRIVER_BRAKING);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the wipers\n     * @return {UnsubscribeVehicleData}\n     */\n    setWiperStatus (status) {\n        this.setParameter(UnsubscribeVehicleData.KEY_WIPER_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getWiperStatus () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_WIPER_STATUS);\n    }\n\n    /**\n     * @param {Boolean} status - Status of the head lamps\n     * @return {UnsubscribeVehicleData}\n     */\n    setHeadLampStatus (status) {\n        this.setParameter(UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeadLampStatus () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS);\n    }\n\n    /**\n     * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants\n     * @return {UnsubscribeVehicleData}\n     */\n    setEngineTorque (torque) {\n        this.setParameter(UnsubscribeVehicleData.KEY_ENGINE_TORQUE, torque);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEngineTorque () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_ENGINE_TORQUE);\n    }\n\n    /**\n     * @param {Boolean} position - Accelerator pedal position (percentage depressed)\n     * @return {UnsubscribeVehicleData}\n     */\n    setAccPedalPosition (position) {\n        this.setParameter(UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAccPedalPosition () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION);\n    }\n\n    /**\n     * @param {Boolean} angle - Current angle of the steering wheel (in deg)\n     * @return {UnsubscribeVehicleData}\n     */\n    setSteeringWheelAngle (angle) {\n        this.setParameter(UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSteeringWheelAngle () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE);\n    }\n\n    /**\n     * @param {Boolean} life - The estimated percentage of remaining oil life of the engine.\n     * @return {UnsubscribeVehicleData}\n     */\n    setEngineOilLife (life) {\n        this.setParameter(UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE, life);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEngineOilLife () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system.\n     * @return {UnsubscribeVehicleData}\n     */\n    setElectronicParkBrakeStatus (status) {\n        this.setParameter(UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getElectronicParkBrakeStatus () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} id - Parameter used by cloud apps to identify a head unit\n     * @return {UnsubscribeVehicleData}\n     */\n    setCloudAppVehicleID (id) {\n        this.setParameter(UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCloudAppVehicleID () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID);\n    }\n\n    /**\n     * @param {Boolean} info - Emergency Call notification and confirmation data\n     * @return {UnsubscribeVehicleData}\n     */\n    setECallInfo (info) {\n        this.setParameter(UnsubscribeVehicleData.KEY_E_CALL_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getECallInfo () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_E_CALL_INFO);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the air bags\n     * @return {UnsubscribeVehicleData}\n     */\n    setAirbagStatus (status) {\n        this.setParameter(UnsubscribeVehicleData.KEY_AIRBAG_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAirbagStatus () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_AIRBAG_STATUS);\n    }\n\n    /**\n     * @param {Boolean} event - Information related to an emergency event (and if it occurred)\n     * @return {UnsubscribeVehicleData}\n     */\n    setEmergencyEvent (event) {\n        this.setParameter(UnsubscribeVehicleData.KEY_EMERGENCY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEmergencyEvent () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_EMERGENCY_EVENT);\n    }\n\n    /**\n     * @param {Boolean} status - The status modes of the cluster\n     * @return {UnsubscribeVehicleData}\n     */\n    setClusterModeStatus (status) {\n        this.setParameter(UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getClusterModeStatus () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} key - Information related to the MyKey feature\n     * @return {UnsubscribeVehicleData}\n     */\n    setMyKey (key) {\n        this.setParameter(UnsubscribeVehicleData.KEY_MY_KEY, key);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMyKey () {\n        return this.getParameter(UnsubscribeVehicleData.KEY_MY_KEY);\n    }\n}\n\nUnsubscribeVehicleData.KEY_GPS = 'gps';\nUnsubscribeVehicleData.KEY_SPEED = 'speed';\nUnsubscribeVehicleData.KEY_RPM = 'rpm';\nUnsubscribeVehicleData.KEY_FUEL_LEVEL = 'fuelLevel';\nUnsubscribeVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State';\nUnsubscribeVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption';\nUnsubscribeVehicleData.KEY_FUEL_RANGE = 'fuelRange';\nUnsubscribeVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature';\nUnsubscribeVehicleData.KEY_TURN_SIGNAL = 'turnSignal';\nUnsubscribeVehicleData.KEY_PRNDL = 'prndl';\nUnsubscribeVehicleData.KEY_TIRE_PRESSURE = 'tirePressure';\nUnsubscribeVehicleData.KEY_ODOMETER = 'odometer';\nUnsubscribeVehicleData.KEY_BELT_STATUS = 'beltStatus';\nUnsubscribeVehicleData.KEY_BODY_INFORMATION = 'bodyInformation';\nUnsubscribeVehicleData.KEY_DEVICE_STATUS = 'deviceStatus';\nUnsubscribeVehicleData.KEY_DRIVER_BRAKING = 'driverBraking';\nUnsubscribeVehicleData.KEY_WIPER_STATUS = 'wiperStatus';\nUnsubscribeVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus';\nUnsubscribeVehicleData.KEY_ENGINE_TORQUE = 'engineTorque';\nUnsubscribeVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition';\nUnsubscribeVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle';\nUnsubscribeVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife';\nUnsubscribeVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus';\nUnsubscribeVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID';\nUnsubscribeVehicleData.KEY_E_CALL_INFO = 'eCallInfo';\nUnsubscribeVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus';\nUnsubscribeVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent';\nUnsubscribeVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus';\nUnsubscribeVehicleData.KEY_MY_KEY = 'myKey';\n\nexport { UnsubscribeVehicleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\nimport { VehicleDataResult } from '../structs/VehicleDataResult.js';\n\nclass UnsubscribeVehicleDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnsubscribeVehicleData);\n    }\n\n    /**\n     * @param {VehicleDataResult} gps - See GPSData\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setGps (gps) {\n        this.validateType(VehicleDataResult, gps);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_GPS, gps);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getGps () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_GPS);\n    }\n\n    /**\n     * @param {VehicleDataResult} speed - The vehicle speed in kilometers per hour\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setSpeed (speed) {\n        this.validateType(VehicleDataResult, speed);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getSpeed () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_SPEED);\n    }\n\n    /**\n     * @param {VehicleDataResult} rpm - The number of revolutions per minute of the engine\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setRpm (rpm) {\n        this.validateType(VehicleDataResult, rpm);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_RPM, rpm);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getRpm () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_RPM);\n    }\n\n    /**\n     * @param {VehicleDataResult} level - The fuel level in the tank (percentage)\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setFuelLevel (level) {\n        this.validateType(VehicleDataResult, level);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getFuelLevel () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL);\n    }\n\n    /**\n     * @param {VehicleDataResult} level_state - The fuel level state\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setFuelLevel_State (level_state) {\n        this.validateType(VehicleDataResult, level_state);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getFuelLevel_State () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE);\n    }\n\n    /**\n     * @param {VehicleDataResult} consumption - The instantaneous fuel consumption in microlitres\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setInstantFuelConsumption (consumption) {\n        this.validateType(VehicleDataResult, consumption);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getInstantFuelConsumption () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION);\n    }\n\n    /**\n     * @param {VehicleDataResult} range - The estimate range in KM the vehicle can travel based on fuel level and\n     *                                    consumption\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setFuelRange (range) {\n        this.validateType(VehicleDataResult, range);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getFuelRange () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_FUEL_RANGE);\n    }\n\n    /**\n     * @param {VehicleDataResult} temperature - The external temperature in degrees celsius\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setExternalTemperature (temperature) {\n        this.validateType(VehicleDataResult, temperature);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getExternalTemperature () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE);\n    }\n\n    /**\n     * @param {VehicleDataResult} signal - See TurnSignal\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setTurnSignal (signal) {\n        this.validateType(VehicleDataResult, signal);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL, signal);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getTurnSignal () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL);\n    }\n\n    /**\n     * @param {VehicleDataResult} prndl - See PRNDL\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setPrndl (prndl) {\n        this.validateType(VehicleDataResult, prndl);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_PRNDL, prndl);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getPrndl () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_PRNDL);\n    }\n\n    /**\n     * @param {VehicleDataResult} pressure - See TireStatus\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setTirePressure (pressure) {\n        this.validateType(VehicleDataResult, pressure);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getTirePressure () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE);\n    }\n\n    /**\n     * @param {VehicleDataResult} odometer - Odometer in km\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setOdometer (odometer) {\n        this.validateType(VehicleDataResult, odometer);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_ODOMETER, odometer);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getOdometer () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ODOMETER);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the seat belts\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setBeltStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_BELT_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getBeltStatus () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_BELT_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} information - The body information including power modes\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setBodyInformation (information) {\n        this.validateType(VehicleDataResult, information);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION, information);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getBodyInformation () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The device status including signal and battery strength\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setDeviceStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getDeviceStatus () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} braking - The status of the brake pedal\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setDriverBraking (braking) {\n        this.validateType(VehicleDataResult, braking);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING, braking);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getDriverBraking () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the wipers\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setWiperStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getWiperStatus () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_WIPER_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - Status of the head lamps\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setHeadLampStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getHeadLampStatus () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} torque - Torque value for engine (in Nm) on non-diesel variants\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setEngineTorque (torque) {\n        this.validateType(VehicleDataResult, torque);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE, torque);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getEngineTorque () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE);\n    }\n\n    /**\n     * @param {VehicleDataResult} position - Accelerator pedal position (percentage depressed)\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setAccPedalPosition (position) {\n        this.validateType(VehicleDataResult, position);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getAccPedalPosition () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION);\n    }\n\n    /**\n     * @param {VehicleDataResult} angle - Current angle of the steering wheel (in deg)\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setSteeringWheelAngle (angle) {\n        this.validateType(VehicleDataResult, angle);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getSteeringWheelAngle () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE);\n    }\n\n    /**\n     * @param {VehicleDataResult} life - The estimated percentage of remaining oil life of the engine.\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setEngineOilLife (life) {\n        this.validateType(VehicleDataResult, life);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getEngineOilLife () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the park brake as provided by Electric Park Brake (EPB) system.\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setElectronicParkBrakeStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getElectronicParkBrakeStatus () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} id - Parameter used by cloud apps to identify a head unit\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setCloudAppVehicleID (id) {\n        this.validateType(VehicleDataResult, id);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getCloudAppVehicleID () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID);\n    }\n\n    /**\n     * @param {VehicleDataResult} info - Emergency Call notification and confirmation data\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setECallInfo (info) {\n        this.validateType(VehicleDataResult, info);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getECallInfo () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_E_CALL_INFO);\n    }\n\n    /**\n     * @param {VehicleDataResult} status - The status of the air bags\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setAirbagStatus (status) {\n        this.validateType(VehicleDataResult, status);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getAirbagStatus () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataResult} event - Information related to an emergency event (and if it occurred)\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setEmergencyEvent (event) {\n        this.validateType(VehicleDataResult, event);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getEmergencyEvent () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT);\n    }\n\n    /**\n     * @param {VehicleDataResult} modes - The status modes of the cluster\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setClusterModes (modes) {\n        this.validateType(VehicleDataResult, modes);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES, modes);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getClusterModes () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES);\n    }\n\n    /**\n     * @param {VehicleDataResult} key - Information related to the MyKey feature\n     * @return {UnsubscribeVehicleDataResponse}\n     */\n    setMyKey (key) {\n        this.validateType(VehicleDataResult, key);\n        this.setParameter(UnsubscribeVehicleDataResponse.KEY_MY_KEY, key);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResult}\n     */\n    getMyKey () {\n        return this.getObject(VehicleDataResult, UnsubscribeVehicleDataResponse.KEY_MY_KEY);\n    }\n}\n\nUnsubscribeVehicleDataResponse.KEY_GPS = 'gps';\nUnsubscribeVehicleDataResponse.KEY_SPEED = 'speed';\nUnsubscribeVehicleDataResponse.KEY_RPM = 'rpm';\nUnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel';\nUnsubscribeVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State';\nUnsubscribeVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption';\nUnsubscribeVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange';\nUnsubscribeVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature';\nUnsubscribeVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal';\nUnsubscribeVehicleDataResponse.KEY_PRNDL = 'prndl';\nUnsubscribeVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure';\nUnsubscribeVehicleDataResponse.KEY_ODOMETER = 'odometer';\nUnsubscribeVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus';\nUnsubscribeVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation';\nUnsubscribeVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus';\nUnsubscribeVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking';\nUnsubscribeVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus';\nUnsubscribeVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus';\nUnsubscribeVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque';\nUnsubscribeVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition';\nUnsubscribeVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle';\nUnsubscribeVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife';\nUnsubscribeVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus';\nUnsubscribeVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID';\nUnsubscribeVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo';\nUnsubscribeVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus';\nUnsubscribeVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent';\nUnsubscribeVehicleDataResponse.KEY_CLUSTER_MODES = 'clusterModes';\nUnsubscribeVehicleDataResponse.KEY_MY_KEY = 'myKey';\n\nexport { UnsubscribeVehicleDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Non periodic vehicle data read request.\n */\nclass GetVehicleData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetVehicleData);\n    }\n\n    /**\n     * @param {Boolean} gps - See GPSData\n     * @return {GetVehicleData}\n     */\n    setGps (gps) {\n        this.setParameter(GetVehicleData.KEY_GPS, gps);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getGps () {\n        return this.getParameter(GetVehicleData.KEY_GPS);\n    }\n\n    /**\n     * @param {Boolean} speed - The vehicle speed in kilometers per hour\n     * @return {GetVehicleData}\n     */\n    setSpeed (speed) {\n        this.setParameter(GetVehicleData.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSpeed () {\n        return this.getParameter(GetVehicleData.KEY_SPEED);\n    }\n\n    /**\n     * @param {Boolean} rpm - The number of revolutions per minute of the engine\n     * @return {GetVehicleData}\n     */\n    setRpm (rpm) {\n        this.setParameter(GetVehicleData.KEY_RPM, rpm);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRpm () {\n        return this.getParameter(GetVehicleData.KEY_RPM);\n    }\n\n    /**\n     * @param {Boolean} level - The fuel level in the tank (percentage)\n     * @return {GetVehicleData}\n     */\n    setFuelLevel (level) {\n        this.setParameter(GetVehicleData.KEY_FUEL_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelLevel () {\n        return this.getParameter(GetVehicleData.KEY_FUEL_LEVEL);\n    }\n\n    /**\n     * @param {Boolean} level_state - The fuel level state\n     * @return {GetVehicleData}\n     */\n    setFuelLevel_State (level_state) {\n        this.setParameter(GetVehicleData.KEY_FUEL_LEVEL_STATE, level_state);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelLevel_State () {\n        return this.getParameter(GetVehicleData.KEY_FUEL_LEVEL_STATE);\n    }\n\n    /**\n     * @param {Boolean} consumption - The instantaneous fuel consumption in microlitres\n     * @return {GetVehicleData}\n     */\n    setInstantFuelConsumption (consumption) {\n        this.setParameter(GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getInstantFuelConsumption () {\n        return this.getParameter(GetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION);\n    }\n\n    /**\n     * @param {Boolean} range - The estimate range in KM the vehicle can travel based on fuel level and consumption\n     * @return {GetVehicleData}\n     */\n    setFuelRange (range) {\n        this.setParameter(GetVehicleData.KEY_FUEL_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFuelRange () {\n        return this.getParameter(GetVehicleData.KEY_FUEL_RANGE);\n    }\n\n    /**\n     * @param {Boolean} temperature - The external temperature in degrees celsius\n     * @return {GetVehicleData}\n     */\n    setExternalTemperature (temperature) {\n        this.setParameter(GetVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getExternalTemperature () {\n        return this.getParameter(GetVehicleData.KEY_EXTERNAL_TEMPERATURE);\n    }\n\n    /**\n     * @param {Boolean} signal - See TurnSignal\n     * @return {GetVehicleData}\n     */\n    setTurnSignal (signal) {\n        this.setParameter(GetVehicleData.KEY_TURN_SIGNAL, signal);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTurnSignal () {\n        return this.getParameter(GetVehicleData.KEY_TURN_SIGNAL);\n    }\n\n    /**\n     * @param {Boolean} vin - Vehicle identification number\n     * @return {GetVehicleData}\n     */\n    setVin (vin) {\n        this.setParameter(GetVehicleData.KEY_VIN, vin);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getVin () {\n        return this.getParameter(GetVehicleData.KEY_VIN);\n    }\n\n    /**\n     * @param {Boolean} prndl - See PRNDL\n     * @return {GetVehicleData}\n     */\n    setPrndl (prndl) {\n        this.setParameter(GetVehicleData.KEY_PRNDL, prndl);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPrndl () {\n        return this.getParameter(GetVehicleData.KEY_PRNDL);\n    }\n\n    /**\n     * @param {Boolean} pressure - See TireStatus\n     * @return {GetVehicleData}\n     */\n    setTirePressure (pressure) {\n        this.setParameter(GetVehicleData.KEY_TIRE_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTirePressure () {\n        return this.getParameter(GetVehicleData.KEY_TIRE_PRESSURE);\n    }\n\n    /**\n     * @param {Boolean} odometer - Odometer in km\n     * @return {GetVehicleData}\n     */\n    setOdometer (odometer) {\n        this.setParameter(GetVehicleData.KEY_ODOMETER, odometer);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getOdometer () {\n        return this.getParameter(GetVehicleData.KEY_ODOMETER);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the seat belts\n     * @return {GetVehicleData}\n     */\n    setBeltStatus (status) {\n        this.setParameter(GetVehicleData.KEY_BELT_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBeltStatus () {\n        return this.getParameter(GetVehicleData.KEY_BELT_STATUS);\n    }\n\n    /**\n     * @param {Boolean} information - The body information including ignition status and internal temp\n     * @return {GetVehicleData}\n     */\n    setBodyInformation (information) {\n        this.setParameter(GetVehicleData.KEY_BODY_INFORMATION, information);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBodyInformation () {\n        return this.getParameter(GetVehicleData.KEY_BODY_INFORMATION);\n    }\n\n    /**\n     * @param {Boolean} status - The device status including signal and battery strength\n     * @return {GetVehicleData}\n     */\n    setDeviceStatus (status) {\n        this.setParameter(GetVehicleData.KEY_DEVICE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDeviceStatus () {\n        return this.getParameter(GetVehicleData.KEY_DEVICE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} braking - The status of the brake pedal\n     * @return {GetVehicleData}\n     */\n    setDriverBraking (braking) {\n        this.setParameter(GetVehicleData.KEY_DRIVER_BRAKING, braking);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDriverBraking () {\n        return this.getParameter(GetVehicleData.KEY_DRIVER_BRAKING);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the wipers\n     * @return {GetVehicleData}\n     */\n    setWiperStatus (status) {\n        this.setParameter(GetVehicleData.KEY_WIPER_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getWiperStatus () {\n        return this.getParameter(GetVehicleData.KEY_WIPER_STATUS);\n    }\n\n    /**\n     * @param {Boolean} status - Status of the head lamps\n     * @return {GetVehicleData}\n     */\n    setHeadLampStatus (status) {\n        this.setParameter(GetVehicleData.KEY_HEAD_LAMP_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeadLampStatus () {\n        return this.getParameter(GetVehicleData.KEY_HEAD_LAMP_STATUS);\n    }\n\n    /**\n     * @param {Boolean} torque - Torque value for engine (in Nm) on non-diesel variants\n     * @return {GetVehicleData}\n     */\n    setEngineTorque (torque) {\n        this.setParameter(GetVehicleData.KEY_ENGINE_TORQUE, torque);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEngineTorque () {\n        return this.getParameter(GetVehicleData.KEY_ENGINE_TORQUE);\n    }\n\n    /**\n     * @param {Boolean} position - Accelerator pedal position (percentage depressed)\n     * @return {GetVehicleData}\n     */\n    setAccPedalPosition (position) {\n        this.setParameter(GetVehicleData.KEY_ACC_PEDAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAccPedalPosition () {\n        return this.getParameter(GetVehicleData.KEY_ACC_PEDAL_POSITION);\n    }\n\n    /**\n     * @param {Boolean} angle - Current angle of the steering wheel (in deg)\n     * @return {GetVehicleData}\n     */\n    setSteeringWheelAngle (angle) {\n        this.setParameter(GetVehicleData.KEY_STEERING_WHEEL_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSteeringWheelAngle () {\n        return this.getParameter(GetVehicleData.KEY_STEERING_WHEEL_ANGLE);\n    }\n\n    /**\n     * @param {Boolean} life - The estimated percentage of remaining oil life of the engine.\n     * @return {GetVehicleData}\n     */\n    setEngineOilLife (life) {\n        this.setParameter(GetVehicleData.KEY_ENGINE_OIL_LIFE, life);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEngineOilLife () {\n        return this.getParameter(GetVehicleData.KEY_ENGINE_OIL_LIFE);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the park brake as provided by Electric Park Brake (EPB) system.\n     * @return {GetVehicleData}\n     */\n    setElectronicParkBrakeStatus (status) {\n        this.setParameter(GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getElectronicParkBrakeStatus () {\n        return this.getParameter(GetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} id - Parameter used by cloud apps to identify a head unit\n     * @return {GetVehicleData}\n     */\n    setCloudAppVehicleID (id) {\n        this.setParameter(GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCloudAppVehicleID () {\n        return this.getParameter(GetVehicleData.KEY_CLOUD_APP_VEHICLE_ID);\n    }\n\n    /**\n     * @param {Boolean} info - Emergency Call notification and confirmation data\n     * @return {GetVehicleData}\n     */\n    setECallInfo (info) {\n        this.setParameter(GetVehicleData.KEY_E_CALL_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getECallInfo () {\n        return this.getParameter(GetVehicleData.KEY_E_CALL_INFO);\n    }\n\n    /**\n     * @param {Boolean} status - The status of the air bags\n     * @return {GetVehicleData}\n     */\n    setAirbagStatus (status) {\n        this.setParameter(GetVehicleData.KEY_AIRBAG_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAirbagStatus () {\n        return this.getParameter(GetVehicleData.KEY_AIRBAG_STATUS);\n    }\n\n    /**\n     * @param {Boolean} event - Information related to an emergency event (and if it occurred)\n     * @return {GetVehicleData}\n     */\n    setEmergencyEvent (event) {\n        this.setParameter(GetVehicleData.KEY_EMERGENCY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEmergencyEvent () {\n        return this.getParameter(GetVehicleData.KEY_EMERGENCY_EVENT);\n    }\n\n    /**\n     * @param {Boolean} status - The status modes of the cluster\n     * @return {GetVehicleData}\n     */\n    setClusterModeStatus (status) {\n        this.setParameter(GetVehicleData.KEY_CLUSTER_MODE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getClusterModeStatus () {\n        return this.getParameter(GetVehicleData.KEY_CLUSTER_MODE_STATUS);\n    }\n\n    /**\n     * @param {Boolean} key - Information related to the MyKey feature\n     * @return {GetVehicleData}\n     */\n    setMyKey (key) {\n        this.setParameter(GetVehicleData.KEY_MY_KEY, key);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMyKey () {\n        return this.getParameter(GetVehicleData.KEY_MY_KEY);\n    }\n}\n\nGetVehicleData.KEY_GPS = 'gps';\nGetVehicleData.KEY_SPEED = 'speed';\nGetVehicleData.KEY_RPM = 'rpm';\nGetVehicleData.KEY_FUEL_LEVEL = 'fuelLevel';\nGetVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State';\nGetVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption';\nGetVehicleData.KEY_FUEL_RANGE = 'fuelRange';\nGetVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature';\nGetVehicleData.KEY_TURN_SIGNAL = 'turnSignal';\nGetVehicleData.KEY_VIN = 'vin';\nGetVehicleData.KEY_PRNDL = 'prndl';\nGetVehicleData.KEY_TIRE_PRESSURE = 'tirePressure';\nGetVehicleData.KEY_ODOMETER = 'odometer';\nGetVehicleData.KEY_BELT_STATUS = 'beltStatus';\nGetVehicleData.KEY_BODY_INFORMATION = 'bodyInformation';\nGetVehicleData.KEY_DEVICE_STATUS = 'deviceStatus';\nGetVehicleData.KEY_DRIVER_BRAKING = 'driverBraking';\nGetVehicleData.KEY_WIPER_STATUS = 'wiperStatus';\nGetVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus';\nGetVehicleData.KEY_ENGINE_TORQUE = 'engineTorque';\nGetVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition';\nGetVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle';\nGetVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife';\nGetVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus';\nGetVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID';\nGetVehicleData.KEY_E_CALL_INFO = 'eCallInfo';\nGetVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus';\nGetVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent';\nGetVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus';\nGetVehicleData.KEY_MY_KEY = 'myKey';\n\nexport { GetVehicleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of a vehicle data event; e.g. a seat belt event status.\n * @typedef {Enum} VehicleDataEventStatus\n * @property {Object} _MAP\n */\nclass VehicleDataEventStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDES_NO_EVENT () {\n        return VehicleDataEventStatus._MAP.VDES_NO_EVENT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDES_NO () {\n        return VehicleDataEventStatus._MAP.VDES_NO;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDES_YES () {\n        return VehicleDataEventStatus._MAP.VDES_YES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDES_NOT_SUPPORTED () {\n        return VehicleDataEventStatus._MAP.VDES_NOT_SUPPORTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDES_FAULT () {\n        return VehicleDataEventStatus._MAP.VDES_FAULT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VehicleDataEventStatus._valueForKey(key, VehicleDataEventStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VehicleDataEventStatus._keyForValue(value, VehicleDataEventStatus._MAP);\n    }\n}\n\nVehicleDataEventStatus._MAP = Object.freeze({\n    'VDES_NO_EVENT': 'NO_EVENT',\n    'VDES_NO': 'NO',\n    'VDES_YES': 'YES',\n    'VDES_NOT_SUPPORTED': 'NOT_SUPPORTED',\n    'VDES_FAULT': 'FAULT',\n});\n\nexport { VehicleDataEventStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js';\n\nclass AirbagStatus extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsDrvBag_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setDriverAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsDrvSideBag_D_Ltchd\". See\n     *                                            VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setDriverSideAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverSideAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsDrvCrtnBag_D_Ltchd\". See\n     *                                            VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setDriverCurtainAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverCurtainAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsPasBag_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setPassengerAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getPassengerAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsPasCrtnBag_D_Ltchd\". See\n     *                                            VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setPassengerCurtainAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getPassengerCurtainAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsKneeDrvBag_D_Ltchd\". See\n     *                                            VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setDriverKneeAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverKneeAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsPasSideBag_D_Ltchd\". See\n     *                                            VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setPassengerSideAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getPassengerSideAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsKneePasBag_D_Ltchd\". See\n     *                                            VehicleDataEventStatus.\n     * @return {AirbagStatus}\n     */\n    setPassengerKneeAirbagDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getPassengerKneeAirbagDeployed () {\n        return this.getObject(VehicleDataEventStatus, AirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED);\n    }\n}\n\nAirbagStatus.KEY_DRIVER_AIRBAG_DEPLOYED = 'driverAirbagDeployed';\nAirbagStatus.KEY_DRIVER_SIDE_AIRBAG_DEPLOYED = 'driverSideAirbagDeployed';\nAirbagStatus.KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED = 'driverCurtainAirbagDeployed';\nAirbagStatus.KEY_PASSENGER_AIRBAG_DEPLOYED = 'passengerAirbagDeployed';\nAirbagStatus.KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED = 'passengerCurtainAirbagDeployed';\nAirbagStatus.KEY_DRIVER_KNEE_AIRBAG_DEPLOYED = 'driverKneeAirbagDeployed';\nAirbagStatus.KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED = 'passengerSideAirbagDeployed';\nAirbagStatus.KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED = 'passengerKneeAirbagDeployed';\n\nexport { AirbagStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of the current power mode.\n * @typedef {Enum} PowerModeStatus\n * @property {Object} _MAP\n */\nclass PowerModeStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get KEY_OUT () {\n        return PowerModeStatus._MAP.KEY_OUT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get KEY_RECENTLY_OUT () {\n        return PowerModeStatus._MAP.KEY_RECENTLY_OUT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get KEY_APPROVED_0 () {\n        return PowerModeStatus._MAP.KEY_APPROVED_0;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get POST_ACCESORY_0 () {\n        return PowerModeStatus._MAP.POST_ACCESORY_0;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ACCESORY_1 () {\n        return PowerModeStatus._MAP.ACCESORY_1;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get POST_IGNITION_1 () {\n        return PowerModeStatus._MAP.POST_IGNITION_1;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IGNITION_ON_2 () {\n        return PowerModeStatus._MAP.IGNITION_ON_2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RUNNING_2 () {\n        return PowerModeStatus._MAP.RUNNING_2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CRANK_3 () {\n        return PowerModeStatus._MAP.CRANK_3;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PowerModeStatus._valueForKey(key, PowerModeStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PowerModeStatus._keyForValue(value, PowerModeStatus._MAP);\n    }\n}\n\nPowerModeStatus._MAP = Object.freeze({\n    'KEY_OUT': 'KEY_OUT',\n    'KEY_RECENTLY_OUT': 'KEY_RECENTLY_OUT',\n    'KEY_APPROVED_0': 'KEY_APPROVED_0',\n    'POST_ACCESORY_0': 'POST_ACCESORY_0',\n    'ACCESORY_1': 'ACCESORY_1',\n    'POST_IGNITION_1': 'POST_IGNITION_1',\n    'IGNITION_ON_2': 'IGNITION_ON_2',\n    'RUNNING_2': 'RUNNING_2',\n    'CRANK_3': 'CRANK_3',\n});\n\nexport { PowerModeStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of the current car mode.\n * @typedef {Enum} CarModeStatus\n * @property {Object} _MAP\n */\nclass CarModeStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CMS_NORMAL () {\n        return CarModeStatus._MAP.CMS_NORMAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CMS_FACTORY () {\n        return CarModeStatus._MAP.CMS_FACTORY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CMS_TRANSPORT () {\n        return CarModeStatus._MAP.CMS_TRANSPORT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CMS_CRASH () {\n        return CarModeStatus._MAP.CMS_CRASH;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return CarModeStatus._valueForKey(key, CarModeStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return CarModeStatus._keyForValue(value, CarModeStatus._MAP);\n    }\n}\n\nCarModeStatus._MAP = Object.freeze({\n    'CMS_NORMAL': 'NORMAL',\n    'CMS_FACTORY': 'FACTORY',\n    'CMS_TRANSPORT': 'TRANSPORT',\n    'CMS_CRASH': 'CRASH',\n});\n\nexport { CarModeStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of the current power mode qualification.\n * @typedef {Enum} PowerModeQualificationStatus\n * @property {Object} _MAP\n */\nclass PowerModeQualificationStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get POWER_MODE_UNDEFINED () {\n        return PowerModeQualificationStatus._MAP.POWER_MODE_UNDEFINED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get POWER_MODE_EVALUATION_IN_PROGRESS () {\n        return PowerModeQualificationStatus._MAP.POWER_MODE_EVALUATION_IN_PROGRESS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NOT_DEFINED () {\n        return PowerModeQualificationStatus._MAP.NOT_DEFINED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get POWER_MODE_OK () {\n        return PowerModeQualificationStatus._MAP.POWER_MODE_OK;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PowerModeQualificationStatus._valueForKey(key, PowerModeQualificationStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PowerModeQualificationStatus._keyForValue(value, PowerModeQualificationStatus._MAP);\n    }\n}\n\nPowerModeQualificationStatus._MAP = Object.freeze({\n    'POWER_MODE_UNDEFINED': 'POWER_MODE_UNDEFINED',\n    'POWER_MODE_EVALUATION_IN_PROGRESS': 'POWER_MODE_EVALUATION_IN_PROGRESS',\n    'NOT_DEFINED': 'NOT_DEFINED',\n    'POWER_MODE_OK': 'POWER_MODE_OK',\n});\n\nexport { PowerModeQualificationStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { PowerModeStatus } from '../enums/PowerModeStatus.js';\nimport { CarModeStatus } from '../enums/CarModeStatus.js';\nimport { PowerModeQualificationStatus } from '../enums/PowerModeQualificationStatus.js';\n\nclass ClusterModeStatus extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} active - References signal \"PowerMode_UB\".\n     * @return {ClusterModeStatus}\n     */\n    setPowerModeActive (active) {\n        this.setParameter(ClusterModeStatus.KEY_POWER_MODE_ACTIVE, active);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPowerModeActive () {\n        return this.getParameter(ClusterModeStatus.KEY_POWER_MODE_ACTIVE);\n    }\n\n    /**\n     * @param {PowerModeQualificationStatus} status - References signal \"PowerModeQF\". See PowerModeQualificationStatus.\n     * @return {ClusterModeStatus}\n     */\n    setPowerModeQualificationStatus (status) {\n        this.validateType(PowerModeQualificationStatus, status);\n        this.setParameter(ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {PowerModeQualificationStatus}\n     */\n    getPowerModeQualificationStatus () {\n        return this.getObject(PowerModeQualificationStatus, ClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS);\n    }\n\n    /**\n     * @param {CarModeStatus} status - References signal \"CarMode\". See CarMode.\n     * @return {ClusterModeStatus}\n     */\n    setCarModeStatus (status) {\n        this.validateType(CarModeStatus, status);\n        this.setParameter(ClusterModeStatus.KEY_CAR_MODE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {CarModeStatus}\n     */\n    getCarModeStatus () {\n        return this.getObject(CarModeStatus, ClusterModeStatus.KEY_CAR_MODE_STATUS);\n    }\n\n    /**\n     * @param {PowerModeStatus} status - References signal \"PowerMode\". See PowerMode.\n     * @return {ClusterModeStatus}\n     */\n    setPowerModeStatus (status) {\n        this.validateType(PowerModeStatus, status);\n        this.setParameter(ClusterModeStatus.KEY_POWER_MODE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {PowerModeStatus}\n     */\n    getPowerModeStatus () {\n        return this.getObject(PowerModeStatus, ClusterModeStatus.KEY_POWER_MODE_STATUS);\n    }\n}\n\nClusterModeStatus.KEY_POWER_MODE_ACTIVE = 'powerModeActive';\nClusterModeStatus.KEY_POWER_MODE_QUALIFICATION_STATUS = 'powerModeQualificationStatus';\nClusterModeStatus.KEY_CAR_MODE_STATUS = 'carModeStatus';\nClusterModeStatus.KEY_POWER_MODE_STATUS = 'powerModeStatus';\n\nexport { ClusterModeStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of the RCM fuel cutoff.\n * @typedef {Enum} FuelCutoffStatus\n * @property {Object} _MAP\n */\nclass FuelCutoffStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FCS_TERMINATE_FUEL () {\n        return FuelCutoffStatus._MAP.FCS_TERMINATE_FUEL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FCS_NORMAL_OPERATION () {\n        return FuelCutoffStatus._MAP.FCS_NORMAL_OPERATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FCS_FAULT () {\n        return FuelCutoffStatus._MAP.FCS_FAULT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return FuelCutoffStatus._valueForKey(key, FuelCutoffStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return FuelCutoffStatus._keyForValue(value, FuelCutoffStatus._MAP);\n    }\n}\n\nFuelCutoffStatus._MAP = Object.freeze({\n    'FCS_TERMINATE_FUEL': 'TERMINATE_FUEL',\n    'FCS_NORMAL_OPERATION': 'NORMAL_OPERATION',\n    'FCS_FAULT': 'FAULT',\n});\n\nexport { FuelCutoffStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the emergency event status of the vehicle.\n * @typedef {Enum} EmergencyEventType\n * @property {Object} _MAP\n */\nclass EmergencyEventType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EET_NO_EVENT () {\n        return EmergencyEventType._MAP.EET_NO_EVENT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EET_FRONTAL () {\n        return EmergencyEventType._MAP.EET_FRONTAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EET_SIDE () {\n        return EmergencyEventType._MAP.EET_SIDE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EET_REAR () {\n        return EmergencyEventType._MAP.EET_REAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EET_ROLLOVER () {\n        return EmergencyEventType._MAP.EET_ROLLOVER;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EET_NOT_SUPPORTED () {\n        return EmergencyEventType._MAP.EET_NOT_SUPPORTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EET_FAULT () {\n        return EmergencyEventType._MAP.EET_FAULT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return EmergencyEventType._valueForKey(key, EmergencyEventType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return EmergencyEventType._keyForValue(value, EmergencyEventType._MAP);\n    }\n}\n\nEmergencyEventType._MAP = Object.freeze({\n    'EET_NO_EVENT': 'NO_EVENT',\n    'EET_FRONTAL': 'FRONTAL',\n    'EET_SIDE': 'SIDE',\n    'EET_REAR': 'REAR',\n    'EET_ROLLOVER': 'ROLLOVER',\n    'EET_NOT_SUPPORTED': 'NOT_SUPPORTED',\n    'EET_FAULT': 'FAULT',\n});\n\nexport { EmergencyEventType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { FuelCutoffStatus } from '../enums/FuelCutoffStatus.js';\nimport { EmergencyEventType } from '../enums/EmergencyEventType.js';\nimport { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js';\n\nclass EmergencyEvent extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {EmergencyEventType} type - References signal \"VedsEvntType_D_Ltchd\". See EmergencyEventType.\n     * @return {EmergencyEvent}\n     */\n    setEmergencyEventType (type) {\n        this.validateType(EmergencyEventType, type);\n        this.setParameter(EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {EmergencyEventType}\n     */\n    getEmergencyEventType () {\n        return this.getObject(EmergencyEventType, EmergencyEvent.KEY_EMERGENCY_EVENT_TYPE);\n    }\n\n    /**\n     * @param {FuelCutoffStatus} status - References signal \"RCM_FuelCutoff\". See FuelCutoffStatus.\n     * @return {EmergencyEvent}\n     */\n    setFuelCutoffStatus (status) {\n        this.validateType(FuelCutoffStatus, status);\n        this.setParameter(EmergencyEvent.KEY_FUEL_CUTOFF_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {FuelCutoffStatus}\n     */\n    getFuelCutoffStatus () {\n        return this.getObject(FuelCutoffStatus, EmergencyEvent.KEY_FUEL_CUTOFF_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} event - References signal \"VedsEvntRoll_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {EmergencyEvent}\n     */\n    setRolloverEvent (event) {\n        this.validateType(VehicleDataEventStatus, event);\n        this.setParameter(EmergencyEvent.KEY_ROLLOVER_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getRolloverEvent () {\n        return this.getObject(VehicleDataEventStatus, EmergencyEvent.KEY_ROLLOVER_EVENT);\n    }\n\n    /**\n     * @param {Number} velocity - References signal \"VedsMaxDeltaV_D_Ltchd\". Change in velocity in KPH. Additional\n     *                            reserved values: 0x00 No event 0xFE Not supported 0xFF Fault\n     * @return {EmergencyEvent}\n     */\n    setMaximumChangeVelocity (velocity) {\n        this.setParameter(EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY, velocity);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaximumChangeVelocity () {\n        return this.getParameter(EmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} events - References signal \"VedsMultiEvnt_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {EmergencyEvent}\n     */\n    setMultipleEvents (events) {\n        this.validateType(VehicleDataEventStatus, events);\n        this.setParameter(EmergencyEvent.KEY_MULTIPLE_EVENTS, events);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getMultipleEvents () {\n        return this.getObject(VehicleDataEventStatus, EmergencyEvent.KEY_MULTIPLE_EVENTS);\n    }\n}\n\nEmergencyEvent.KEY_EMERGENCY_EVENT_TYPE = 'emergencyEventType';\nEmergencyEvent.KEY_FUEL_CUTOFF_STATUS = 'fuelCutoffStatus';\nEmergencyEvent.KEY_ROLLOVER_EVENT = 'rolloverEvent';\nEmergencyEvent.KEY_MAXIMUM_CHANGE_VELOCITY = 'maximumChangeVelocity';\nEmergencyEvent.KEY_MULTIPLE_EVENTS = 'multipleEvents';\n\nexport { EmergencyEvent };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes the status of the turn light indicator.\n * @typedef {Enum} TurnSignal\n * @property {Object} _MAP\n */\nclass TurnSignal extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Turn signal is OFF\n     * @return {String}\n     */\n    static get OFF () {\n        return TurnSignal._MAP.OFF;\n    }\n\n    /**\n     * Left turn signal is on\n     * @return {String}\n     */\n    static get LEFT () {\n        return TurnSignal._MAP.LEFT;\n    }\n\n    /**\n     * Right turn signal is on\n     * @return {String}\n     */\n    static get RIGHT () {\n        return TurnSignal._MAP.RIGHT;\n    }\n\n    /**\n     * Both signals (left and right) are on.\n     * @return {String}\n     */\n    static get BOTH () {\n        return TurnSignal._MAP.BOTH;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TurnSignal._valueForKey(key, TurnSignal._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TurnSignal._keyForValue(value, TurnSignal._MAP);\n    }\n}\n\nTurnSignal._MAP = Object.freeze({\n    'OFF': 'OFF',\n    'LEFT': 'LEFT',\n    'RIGHT': 'RIGHT',\n    'BOTH': 'BOTH',\n});\n\nexport { TurnSignal };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of the ambient light sensor.\n * @typedef {Enum} AmbientLightStatus\n * @property {Object} _MAP\n */\nclass AmbientLightStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NIGHT () {\n        return AmbientLightStatus._MAP.NIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TWILIGHT_1 () {\n        return AmbientLightStatus._MAP.TWILIGHT_1;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TWILIGHT_2 () {\n        return AmbientLightStatus._MAP.TWILIGHT_2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TWILIGHT_3 () {\n        return AmbientLightStatus._MAP.TWILIGHT_3;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TWILIGHT_4 () {\n        return AmbientLightStatus._MAP.TWILIGHT_4;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DAY () {\n        return AmbientLightStatus._MAP.DAY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ALS_UNKNOWN () {\n        return AmbientLightStatus._MAP.ALS_UNKNOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INVALID () {\n        return AmbientLightStatus._MAP.INVALID;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return AmbientLightStatus._valueForKey(key, AmbientLightStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return AmbientLightStatus._keyForValue(value, AmbientLightStatus._MAP);\n    }\n}\n\nAmbientLightStatus._MAP = Object.freeze({\n    'NIGHT': 'NIGHT',\n    'TWILIGHT_1': 'TWILIGHT_1',\n    'TWILIGHT_2': 'TWILIGHT_2',\n    'TWILIGHT_3': 'TWILIGHT_3',\n    'TWILIGHT_4': 'TWILIGHT_4',\n    'DAY': 'DAY',\n    'ALS_UNKNOWN': 'UNKNOWN',\n    'INVALID': 'INVALID',\n});\n\nexport { AmbientLightStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { AmbientLightStatus } from '../enums/AmbientLightStatus.js';\n\nclass HeadLampStatus extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} on - Status of the low beam lamps. References signal \"HeadLampLoActv_B_Stat\".\n     * @return {HeadLampStatus}\n     */\n    setLowBeamsOn (on) {\n        this.setParameter(HeadLampStatus.KEY_LOW_BEAMS_ON, on);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getLowBeamsOn () {\n        return this.getParameter(HeadLampStatus.KEY_LOW_BEAMS_ON);\n    }\n\n    /**\n     * @param {Boolean} on - Status of the high beam lamps. References signal \"HeadLghtHiOn_B_Stat\".\n     * @return {HeadLampStatus}\n     */\n    setHighBeamsOn (on) {\n        this.setParameter(HeadLampStatus.KEY_HIGH_BEAMS_ON, on);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHighBeamsOn () {\n        return this.getParameter(HeadLampStatus.KEY_HIGH_BEAMS_ON);\n    }\n\n    /**\n     * @param {AmbientLightStatus} status - Status of the ambient light sensor.\n     * @return {HeadLampStatus}\n     */\n    setAmbientLightSensorStatus (status) {\n        this.validateType(AmbientLightStatus, status);\n        this.setParameter(HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {AmbientLightStatus}\n     */\n    getAmbientLightSensorStatus () {\n        return this.getObject(AmbientLightStatus, HeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS);\n    }\n}\n\nHeadLampStatus.KEY_LOW_BEAMS_ON = 'lowBeamsOn';\nHeadLampStatus.KEY_HIGH_BEAMS_ON = 'highBeamsOn';\nHeadLampStatus.KEY_AMBIENT_LIGHT_SENSOR_STATUS = 'ambientLightSensorStatus';\n\nexport { HeadLampStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the current primary audio source (if selected).\n * @typedef {Enum} PrimaryAudioSource\n * @property {Object} _MAP\n */\nclass PrimaryAudioSource extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NO_SOURCE_SELECTED () {\n        return PrimaryAudioSource._MAP.NO_SOURCE_SELECTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CD () {\n        return PrimaryAudioSource._MAP.CD;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get USB () {\n        return PrimaryAudioSource._MAP.USB;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get USB2 () {\n        return PrimaryAudioSource._MAP.USB2;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BLUETOOTH_STEREO_BTST () {\n        return PrimaryAudioSource._MAP.BLUETOOTH_STEREO_BTST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LINE_IN () {\n        return PrimaryAudioSource._MAP.LINE_IN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IPOD () {\n        return PrimaryAudioSource._MAP.IPOD;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MOBILE_APP () {\n        return PrimaryAudioSource._MAP.MOBILE_APP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AM () {\n        return PrimaryAudioSource._MAP.AM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FM () {\n        return PrimaryAudioSource._MAP.FM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get XM () {\n        return PrimaryAudioSource._MAP.XM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DAB () {\n        return PrimaryAudioSource._MAP.DAB;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PrimaryAudioSource._valueForKey(key, PrimaryAudioSource._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PrimaryAudioSource._keyForValue(value, PrimaryAudioSource._MAP);\n    }\n}\n\nPrimaryAudioSource._MAP = Object.freeze({\n    'NO_SOURCE_SELECTED': 'NO_SOURCE_SELECTED',\n    'CD': 'CD',\n    'USB': 'USB',\n    'USB2': 'USB2',\n    'BLUETOOTH_STEREO_BTST': 'BLUETOOTH_STEREO_BTST',\n    'LINE_IN': 'LINE_IN',\n    'IPOD': 'IPOD',\n    'MOBILE_APP': 'MOBILE_APP',\n    'AM': 'AM',\n    'FM': 'FM',\n    'XM': 'XM',\n    'DAB': 'DAB',\n});\n\nexport { PrimaryAudioSource };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the reported battery status of the connected device, if reported.\n * @typedef {Enum} DeviceLevelStatus\n * @property {Object} _MAP\n */\nclass DeviceLevelStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ZERO_LEVEL_BARS () {\n        return DeviceLevelStatus._MAP.ZERO_LEVEL_BARS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ONE_LEVEL_BARS () {\n        return DeviceLevelStatus._MAP.ONE_LEVEL_BARS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TWO_LEVEL_BARS () {\n        return DeviceLevelStatus._MAP.TWO_LEVEL_BARS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get THREE_LEVEL_BARS () {\n        return DeviceLevelStatus._MAP.THREE_LEVEL_BARS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FOUR_LEVEL_BARS () {\n        return DeviceLevelStatus._MAP.FOUR_LEVEL_BARS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NOT_PROVIDED () {\n        return DeviceLevelStatus._MAP.NOT_PROVIDED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return DeviceLevelStatus._valueForKey(key, DeviceLevelStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return DeviceLevelStatus._keyForValue(value, DeviceLevelStatus._MAP);\n    }\n}\n\nDeviceLevelStatus._MAP = Object.freeze({\n    'ZERO_LEVEL_BARS': 'ZERO_LEVEL_BARS',\n    'ONE_LEVEL_BARS': 'ONE_LEVEL_BARS',\n    'TWO_LEVEL_BARS': 'TWO_LEVEL_BARS',\n    'THREE_LEVEL_BARS': 'THREE_LEVEL_BARS',\n    'FOUR_LEVEL_BARS': 'FOUR_LEVEL_BARS',\n    'NOT_PROVIDED': 'NOT_PROVIDED',\n});\n\nexport { DeviceLevelStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { PrimaryAudioSource } from '../enums/PrimaryAudioSource.js';\nimport { DeviceLevelStatus } from '../enums/DeviceLevelStatus.js';\n\nclass DeviceStatus extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} on - References signal \"CPM_VoiceRec_STAT\".\n     * @return {DeviceStatus}\n     */\n    setVoiceRecOn (on) {\n        this.setParameter(DeviceStatus.KEY_VOICE_REC_ON, on);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getVoiceRecOn () {\n        return this.getParameter(DeviceStatus.KEY_VOICE_REC_ON);\n    }\n\n    /**\n     * @param {Boolean} on - References signal \"BT_ICON\".\n     * @return {DeviceStatus}\n     */\n    setBtIconOn (on) {\n        this.setParameter(DeviceStatus.KEY_BT_ICON_ON, on);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBtIconOn () {\n        return this.getParameter(DeviceStatus.KEY_BT_ICON_ON);\n    }\n\n    /**\n     * @param {Boolean} active - References signal \"CPM_Call_Active_STAT\".\n     * @return {DeviceStatus}\n     */\n    setCallActive (active) {\n        this.setParameter(DeviceStatus.KEY_CALL_ACTIVE, active);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCallActive () {\n        return this.getParameter(DeviceStatus.KEY_CALL_ACTIVE);\n    }\n\n    /**\n     * @param {Boolean} roaming - References signal \"CPM_Phone_Roaming_STAT\".\n     * @return {DeviceStatus}\n     */\n    setPhoneRoaming (roaming) {\n        this.setParameter(DeviceStatus.KEY_PHONE_ROAMING, roaming);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPhoneRoaming () {\n        return this.getParameter(DeviceStatus.KEY_PHONE_ROAMING);\n    }\n\n    /**\n     * @param {Boolean} available - References signal \"CPM_TextMsg_AVAL\".\n     * @return {DeviceStatus}\n     */\n    setTextMsgAvailable (available) {\n        this.setParameter(DeviceStatus.KEY_TEXT_MSG_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTextMsgAvailable () {\n        return this.getParameter(DeviceStatus.KEY_TEXT_MSG_AVAILABLE);\n    }\n\n    /**\n     * @param {DeviceLevelStatus} status - Device battery level status. References signal \"CPM_Batt_Level_STAT\". See\n     *                                     DeviceLevelStatus.\n     * @return {DeviceStatus}\n     */\n    setBattLevelStatus (status) {\n        this.validateType(DeviceLevelStatus, status);\n        this.setParameter(DeviceStatus.KEY_BATT_LEVEL_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {DeviceLevelStatus}\n     */\n    getBattLevelStatus () {\n        return this.getObject(DeviceLevelStatus, DeviceStatus.KEY_BATT_LEVEL_STATUS);\n    }\n\n    /**\n     * @param {Boolean} muted - References signal \"CPM_Stereo_Audio_Output\".\n     * @return {DeviceStatus}\n     */\n    setStereoAudioOutputMuted (muted) {\n        this.setParameter(DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED, muted);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getStereoAudioOutputMuted () {\n        return this.getParameter(DeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED);\n    }\n\n    /**\n     * @param {Boolean} muted - References signal \"CPM_Mono_Audio_Output\".\n     * @return {DeviceStatus}\n     */\n    setMonoAudioOutputMuted (muted) {\n        this.setParameter(DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED, muted);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMonoAudioOutputMuted () {\n        return this.getParameter(DeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED);\n    }\n\n    /**\n     * @param {DeviceLevelStatus} status - Device signal level status. References signal \"CPM_Signal_Strength_STAT\". See\n     *                                     DeviceLevelStatus.\n     * @return {DeviceStatus}\n     */\n    setSignalLevelStatus (status) {\n        this.validateType(DeviceLevelStatus, status);\n        this.setParameter(DeviceStatus.KEY_SIGNAL_LEVEL_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {DeviceLevelStatus}\n     */\n    getSignalLevelStatus () {\n        return this.getObject(DeviceLevelStatus, DeviceStatus.KEY_SIGNAL_LEVEL_STATUS);\n    }\n\n    /**\n     * @param {PrimaryAudioSource} source - References signal \"CPM_Stereo_PAS_Source\". See PrimaryAudioSource.\n     * @return {DeviceStatus}\n     */\n    setPrimaryAudioSource (source) {\n        this.validateType(PrimaryAudioSource, source);\n        this.setParameter(DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE, source);\n        return this;\n    }\n\n    /**\n     * @return {PrimaryAudioSource}\n     */\n    getPrimaryAudioSource () {\n        return this.getObject(PrimaryAudioSource, DeviceStatus.KEY_PRIMARY_AUDIO_SOURCE);\n    }\n\n    /**\n     * @param {Boolean} active - References signal \"eCall_Event\".\n     * @return {DeviceStatus}\n     */\n    setECallEventActive (active) {\n        this.setParameter(DeviceStatus.KEY_E_CALL_EVENT_ACTIVE, active);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getECallEventActive () {\n        return this.getParameter(DeviceStatus.KEY_E_CALL_EVENT_ACTIVE);\n    }\n}\n\nDeviceStatus.KEY_VOICE_REC_ON = 'voiceRecOn';\nDeviceStatus.KEY_BT_ICON_ON = 'btIconOn';\nDeviceStatus.KEY_CALL_ACTIVE = 'callActive';\nDeviceStatus.KEY_PHONE_ROAMING = 'phoneRoaming';\nDeviceStatus.KEY_TEXT_MSG_AVAILABLE = 'textMsgAvailable';\nDeviceStatus.KEY_BATT_LEVEL_STATUS = 'battLevelStatus';\nDeviceStatus.KEY_STEREO_AUDIO_OUTPUT_MUTED = 'stereoAudioOutputMuted';\nDeviceStatus.KEY_MONO_AUDIO_OUTPUT_MUTED = 'monoAudioOutputMuted';\nDeviceStatus.KEY_SIGNAL_LEVEL_STATUS = 'signalLevelStatus';\nDeviceStatus.KEY_PRIMARY_AUDIO_SOURCE = 'primaryAudioSource';\nDeviceStatus.KEY_E_CALL_EVENT_ACTIVE = 'eCallEventActive';\n\nexport { DeviceStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of the wipers.\n * @typedef {Enum} WiperStatus\n * @property {Object} _MAP\n */\nclass WiperStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OFF () {\n        return WiperStatus._MAP.OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTO_OFF () {\n        return WiperStatus._MAP.AUTO_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OFF_MOVING () {\n        return WiperStatus._MAP.OFF_MOVING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MAN_INT_OFF () {\n        return WiperStatus._MAP.MAN_INT_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MAN_INT_ON () {\n        return WiperStatus._MAP.MAN_INT_ON;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MAN_LOW () {\n        return WiperStatus._MAP.MAN_LOW;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MAN_HIGH () {\n        return WiperStatus._MAP.MAN_HIGH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MAN_FLICK () {\n        return WiperStatus._MAP.MAN_FLICK;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WASH () {\n        return WiperStatus._MAP.WASH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTO_LOW () {\n        return WiperStatus._MAP.AUTO_LOW;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTO_HIGH () {\n        return WiperStatus._MAP.AUTO_HIGH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get COURTESYWIPE () {\n        return WiperStatus._MAP.COURTESYWIPE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTO_ADJUST () {\n        return WiperStatus._MAP.AUTO_ADJUST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get STALLED () {\n        return WiperStatus._MAP.STALLED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NO_DATA_EXISTS () {\n        return WiperStatus._MAP.NO_DATA_EXISTS;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return WiperStatus._valueForKey(key, WiperStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return WiperStatus._keyForValue(value, WiperStatus._MAP);\n    }\n}\n\nWiperStatus._MAP = Object.freeze({\n    'OFF': 'OFF',\n    'AUTO_OFF': 'AUTO_OFF',\n    'OFF_MOVING': 'OFF_MOVING',\n    'MAN_INT_OFF': 'MAN_INT_OFF',\n    'MAN_INT_ON': 'MAN_INT_ON',\n    'MAN_LOW': 'MAN_LOW',\n    'MAN_HIGH': 'MAN_HIGH',\n    'MAN_FLICK': 'MAN_FLICK',\n    'WASH': 'WASH',\n    'AUTO_LOW': 'AUTO_LOW',\n    'AUTO_HIGH': 'AUTO_HIGH',\n    'COURTESYWIPE': 'COURTESYWIPE',\n    'AUTO_ADJUST': 'AUTO_ADJUST',\n    'STALLED': 'STALLED',\n    'NO_DATA_EXISTS': 'NO_DATA_EXISTS',\n});\n\nexport { WiperStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ElectronicParkBrakeStatus\n * @property {Object} _MAP\n */\nclass ElectronicParkBrakeStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Park brake actuators have been fully applied.\n     * @return {String}\n     */\n    static get CLOSED () {\n        return ElectronicParkBrakeStatus._MAP.CLOSED;\n    }\n\n    /**\n     * Park brake actuators are transitioning to either Apply/Closed or Release/Open state.\n     * @return {String}\n     */\n    static get TRANSITION () {\n        return ElectronicParkBrakeStatus._MAP.TRANSITION;\n    }\n\n    /**\n     * Park brake actuators are released.\n     * @return {String}\n     */\n    static get OPEN () {\n        return ElectronicParkBrakeStatus._MAP.OPEN;\n    }\n\n    /**\n     * When driver pulls the Electronic Park Brake switch while driving \"at speed\".\n     * @return {String}\n     */\n    static get DRIVE_ACTIVE () {\n        return ElectronicParkBrakeStatus._MAP.DRIVE_ACTIVE;\n    }\n\n    /**\n     * When system has a fault or is under maintenance.\n     * @return {String}\n     */\n    static get FAULT () {\n        return ElectronicParkBrakeStatus._MAP.FAULT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ElectronicParkBrakeStatus._valueForKey(key, ElectronicParkBrakeStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ElectronicParkBrakeStatus._keyForValue(value, ElectronicParkBrakeStatus._MAP);\n    }\n}\n\nElectronicParkBrakeStatus._MAP = Object.freeze({\n    'CLOSED': 'CLOSED',\n    'TRANSITION': 'TRANSITION',\n    'OPEN': 'OPEN',\n    'DRIVE_ACTIVE': 'DRIVE_ACTIVE',\n    'FAULT': 'FAULT',\n});\n\nexport { ElectronicParkBrakeStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of a binary vehicle data item.\n * @typedef {Enum} VehicleDataStatus\n * @property {Object} _MAP\n */\nclass VehicleDataStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDS_NO_DATA_EXISTS () {\n        return VehicleDataStatus._MAP.VDS_NO_DATA_EXISTS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDS_OFF () {\n        return VehicleDataStatus._MAP.VDS_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDS_ON () {\n        return VehicleDataStatus._MAP.VDS_ON;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VehicleDataStatus._valueForKey(key, VehicleDataStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VehicleDataStatus._keyForValue(value, VehicleDataStatus._MAP);\n    }\n}\n\nVehicleDataStatus._MAP = Object.freeze({\n    'VDS_NO_DATA_EXISTS': 'NO_DATA_EXISTS',\n    'VDS_OFF': 'OFF',\n    'VDS_ON': 'ON',\n});\n\nexport { VehicleDataStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VehicleDataStatus } from '../enums/VehicleDataStatus.js';\n\nclass MyKey extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {VehicleDataStatus} e911override - Indicates whether e911 override is on. References signal\n     *                                           \"MyKey_e911Override_St\". See VehicleDataStatus.\n     * @return {MyKey}\n     */\n    setE911Override (e911override) {\n        this.validateType(VehicleDataStatus, e911override);\n        this.setParameter(MyKey.KEY_E911OVERRIDE, e911override);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataStatus}\n     */\n    getE911Override () {\n        return this.getObject(VehicleDataStatus, MyKey.KEY_E911OVERRIDE);\n    }\n}\n\nMyKey.KEY_E911OVERRIDE = 'e911Override';\n\nexport { MyKey };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The list of potential compass directions\n * @typedef {Enum} CompassDirection\n * @property {Object} _MAP\n */\nclass CompassDirection extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NORTH () {\n        return CompassDirection._MAP.NORTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NORTHWEST () {\n        return CompassDirection._MAP.NORTHWEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WEST () {\n        return CompassDirection._MAP.WEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SOUTHWEST () {\n        return CompassDirection._MAP.SOUTHWEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SOUTH () {\n        return CompassDirection._MAP.SOUTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SOUTHEAST () {\n        return CompassDirection._MAP.SOUTHEAST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EAST () {\n        return CompassDirection._MAP.EAST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NORTHEAST () {\n        return CompassDirection._MAP.NORTHEAST;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return CompassDirection._valueForKey(key, CompassDirection._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return CompassDirection._keyForValue(value, CompassDirection._MAP);\n    }\n}\n\nCompassDirection._MAP = Object.freeze({\n    'NORTH': 'NORTH',\n    'NORTHWEST': 'NORTHWEST',\n    'WEST': 'WEST',\n    'SOUTHWEST': 'SOUTHWEST',\n    'SOUTH': 'SOUTH',\n    'SOUTHEAST': 'SOUTHEAST',\n    'EAST': 'EAST',\n    'NORTHEAST': 'NORTHEAST',\n});\n\nexport { CompassDirection };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The supported dimensions of the GPS\n * @typedef {Enum} Dimension\n * @property {Object} _MAP\n */\nclass Dimension extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * No GPS at all\n     * @return {String}\n     */\n    static get Dimension_NO_FIX () {\n        return Dimension._MAP.Dimension_NO_FIX;\n    }\n\n    /**\n     * Longitude and latitude\n     * @return {String}\n     */\n    static get Dimension_2D () {\n        return Dimension._MAP.Dimension_2D;\n    }\n\n    /**\n     * Longitude and latitude and altitude\n     * @return {String}\n     */\n    static get Dimension_3D () {\n        return Dimension._MAP.Dimension_3D;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return Dimension._valueForKey(key, Dimension._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return Dimension._keyForValue(value, Dimension._MAP);\n    }\n}\n\nDimension._MAP = Object.freeze({\n    'Dimension_NO_FIX': 'NO_FIX',\n    'Dimension_2D': '2D',\n    'Dimension_3D': '3D',\n});\n\nexport { Dimension };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { CompassDirection } from '../enums/CompassDirection.js';\nimport { Dimension } from '../enums/Dimension.js';\n\n/**\n * Struct with the GPS data.\n */\nclass GPSData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} degrees\n     * @return {GPSData}\n     */\n    setLongitudeDegrees (degrees) {\n        this.setParameter(GPSData.KEY_LONGITUDE_DEGREES, degrees);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLongitudeDegrees () {\n        return this.getParameter(GPSData.KEY_LONGITUDE_DEGREES);\n    }\n\n    /**\n     * @param {Number} degrees\n     * @return {GPSData}\n     */\n    setLatitudeDegrees (degrees) {\n        this.setParameter(GPSData.KEY_LATITUDE_DEGREES, degrees);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLatitudeDegrees () {\n        return this.getParameter(GPSData.KEY_LATITUDE_DEGREES);\n    }\n\n    /**\n     * @param {Number} year - The current UTC year.\n     * @return {GPSData}\n     */\n    setUtcYear (year) {\n        this.setParameter(GPSData.KEY_UTC_YEAR, year);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getUtcYear () {\n        return this.getParameter(GPSData.KEY_UTC_YEAR);\n    }\n\n    /**\n     * @param {Number} month - The current UTC month.\n     * @return {GPSData}\n     */\n    setUtcMonth (month) {\n        this.setParameter(GPSData.KEY_UTC_MONTH, month);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getUtcMonth () {\n        return this.getParameter(GPSData.KEY_UTC_MONTH);\n    }\n\n    /**\n     * @param {Number} day - The current UTC day.\n     * @return {GPSData}\n     */\n    setUtcDay (day) {\n        this.setParameter(GPSData.KEY_UTC_DAY, day);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getUtcDay () {\n        return this.getParameter(GPSData.KEY_UTC_DAY);\n    }\n\n    /**\n     * @param {Number} hours - The current UTC hour.\n     * @return {GPSData}\n     */\n    setUtcHours (hours) {\n        this.setParameter(GPSData.KEY_UTC_HOURS, hours);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getUtcHours () {\n        return this.getParameter(GPSData.KEY_UTC_HOURS);\n    }\n\n    /**\n     * @param {Number} minutes - The current UTC minute.\n     * @return {GPSData}\n     */\n    setUtcMinutes (minutes) {\n        this.setParameter(GPSData.KEY_UTC_MINUTES, minutes);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getUtcMinutes () {\n        return this.getParameter(GPSData.KEY_UTC_MINUTES);\n    }\n\n    /**\n     * @param {Number} seconds - The current UTC second.\n     * @return {GPSData}\n     */\n    setUtcSeconds (seconds) {\n        this.setParameter(GPSData.KEY_UTC_SECONDS, seconds);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getUtcSeconds () {\n        return this.getParameter(GPSData.KEY_UTC_SECONDS);\n    }\n\n    /**\n     * @param {CompassDirection} direction - See CompassDirection.\n     * @return {GPSData}\n     */\n    setCompassDirection (direction) {\n        this.validateType(CompassDirection, direction);\n        this.setParameter(GPSData.KEY_COMPASS_DIRECTION, direction);\n        return this;\n    }\n\n    /**\n     * @return {CompassDirection}\n     */\n    getCompassDirection () {\n        return this.getObject(CompassDirection, GPSData.KEY_COMPASS_DIRECTION);\n    }\n\n    /**\n     * @param {Number} pdop - PDOP. If undefined or unavailable, then value shall be set to 0.\n     * @return {GPSData}\n     */\n    setPdop (pdop) {\n        this.setParameter(GPSData.KEY_PDOP, pdop);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPdop () {\n        return this.getParameter(GPSData.KEY_PDOP);\n    }\n\n    /**\n     * @param {Number} hdop - HDOP. If value is unknown, value shall be set to 0.\n     * @return {GPSData}\n     */\n    setHdop (hdop) {\n        this.setParameter(GPSData.KEY_HDOP, hdop);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHdop () {\n        return this.getParameter(GPSData.KEY_HDOP);\n    }\n\n    /**\n     * @param {Number} vdop - VDOP. If value is unknown, value shall be set to 0.\n     * @return {GPSData}\n     */\n    setVdop (vdop) {\n        this.setParameter(GPSData.KEY_VDOP, vdop);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getVdop () {\n        return this.getParameter(GPSData.KEY_VDOP);\n    }\n\n    /**\n     * @param {Boolean} actual - True, if actual. False, if inferred.\n     * @return {GPSData}\n     */\n    setActual (actual) {\n        this.setParameter(GPSData.KEY_ACTUAL, actual);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getActual () {\n        return this.getParameter(GPSData.KEY_ACTUAL);\n    }\n\n    /**\n     * @param {Number} satellites - Number of satellites in view\n     * @return {GPSData}\n     */\n    setSatellites (satellites) {\n        this.setParameter(GPSData.KEY_SATELLITES, satellites);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSatellites () {\n        return this.getParameter(GPSData.KEY_SATELLITES);\n    }\n\n    /**\n     * @param {Dimension} dimension - See Dimension\n     * @return {GPSData}\n     */\n    setDimension (dimension) {\n        this.validateType(Dimension, dimension);\n        this.setParameter(GPSData.KEY_DIMENSION, dimension);\n        return this;\n    }\n\n    /**\n     * @return {Dimension}\n     */\n    getDimension () {\n        return this.getObject(Dimension, GPSData.KEY_DIMENSION);\n    }\n\n    /**\n     * @param {Number} altitude - Altitude in meters\n     * @return {GPSData}\n     */\n    setAltitude (altitude) {\n        this.setParameter(GPSData.KEY_ALTITUDE, altitude);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getAltitude () {\n        return this.getParameter(GPSData.KEY_ALTITUDE);\n    }\n\n    /**\n     * @param {Number} heading - The heading. North is 0. Resolution is 0.01\n     * @return {GPSData}\n     */\n    setHeading (heading) {\n        this.setParameter(GPSData.KEY_HEADING, heading);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHeading () {\n        return this.getParameter(GPSData.KEY_HEADING);\n    }\n\n    /**\n     * @param {Number} speed - The speed in KPH\n     * @return {GPSData}\n     */\n    setSpeed (speed) {\n        this.setParameter(GPSData.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSpeed () {\n        return this.getParameter(GPSData.KEY_SPEED);\n    }\n\n    /**\n     * @param {Boolean} shifted - True, if GPS lat/long, time, and altitude have been purposefully shifted (requires a\n     *                            proprietary algorithm to unshift). False, if the GPS data is raw and un-shifted. If\n     *                            not provided, then value is assumed False.\n     * @return {GPSData}\n     */\n    setShifted (shifted) {\n        this.setParameter(GPSData.KEY_SHIFTED, shifted);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getShifted () {\n        return this.getParameter(GPSData.KEY_SHIFTED);\n    }\n}\n\nGPSData.KEY_LONGITUDE_DEGREES = 'longitudeDegrees';\nGPSData.KEY_LATITUDE_DEGREES = 'latitudeDegrees';\nGPSData.KEY_UTC_YEAR = 'utcYear';\nGPSData.KEY_UTC_MONTH = 'utcMonth';\nGPSData.KEY_UTC_DAY = 'utcDay';\nGPSData.KEY_UTC_HOURS = 'utcHours';\nGPSData.KEY_UTC_MINUTES = 'utcMinutes';\nGPSData.KEY_UTC_SECONDS = 'utcSeconds';\nGPSData.KEY_COMPASS_DIRECTION = 'compassDirection';\nGPSData.KEY_PDOP = 'pdop';\nGPSData.KEY_HDOP = 'hdop';\nGPSData.KEY_VDOP = 'vdop';\nGPSData.KEY_ACTUAL = 'actual';\nGPSData.KEY_SATELLITES = 'satellites';\nGPSData.KEY_DIMENSION = 'dimension';\nGPSData.KEY_ALTITUDE = 'altitude';\nGPSData.KEY_HEADING = 'heading';\nGPSData.KEY_SPEED = 'speed';\nGPSData.KEY_SHIFTED = 'shifted';\n\nexport { GPSData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The selected gear.\n * @typedef {Enum} PRNDL\n * @property {Object} _MAP\n */\nclass PRNDL extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Parking\n     * @return {String}\n     */\n    static get PARK () {\n        return PRNDL._MAP.PARK;\n    }\n\n    /**\n     * Reverse gear\n     * @return {String}\n     */\n    static get REVERSE () {\n        return PRNDL._MAP.REVERSE;\n    }\n\n    /**\n     * No gear\n     * @return {String}\n     */\n    static get NEUTRAL () {\n        return PRNDL._MAP.NEUTRAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DRIVE () {\n        return PRNDL._MAP.DRIVE;\n    }\n\n    /**\n     * Drive Sport mode\n     * @return {String}\n     */\n    static get SPORT () {\n        return PRNDL._MAP.SPORT;\n    }\n\n    /**\n     * 1st gear hold\n     * @return {String}\n     */\n    static get LOWGEAR () {\n        return PRNDL._MAP.LOWGEAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FIRST () {\n        return PRNDL._MAP.FIRST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SECOND () {\n        return PRNDL._MAP.SECOND;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get THIRD () {\n        return PRNDL._MAP.THIRD;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FOURTH () {\n        return PRNDL._MAP.FOURTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FIFTH () {\n        return PRNDL._MAP.FIFTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SIXTH () {\n        return PRNDL._MAP.SIXTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEVENTH () {\n        return PRNDL._MAP.SEVENTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EIGHTH () {\n        return PRNDL._MAP.EIGHTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UNKNOWN () {\n        return PRNDL._MAP.UNKNOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FAULT () {\n        return PRNDL._MAP.FAULT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PRNDL._valueForKey(key, PRNDL._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PRNDL._keyForValue(value, PRNDL._MAP);\n    }\n}\n\nPRNDL._MAP = Object.freeze({\n    'PARK': 'PARK',\n    'REVERSE': 'REVERSE',\n    'NEUTRAL': 'NEUTRAL',\n    'DRIVE': 'DRIVE',\n    'SPORT': 'SPORT',\n    'LOWGEAR': 'LOWGEAR',\n    'FIRST': 'FIRST',\n    'SECOND': 'SECOND',\n    'THIRD': 'THIRD',\n    'FOURTH': 'FOURTH',\n    'FIFTH': 'FIFTH',\n    'SIXTH': 'SIXTH',\n    'SEVENTH': 'SEVENTH',\n    'EIGHTH': 'EIGHTH',\n    'UNKNOWN': 'UNKNOWN',\n    'FAULT': 'FAULT',\n});\n\nexport { PRNDL };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} FuelType\n * @property {Object} _MAP\n */\nclass FuelType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get GASOLINE () {\n        return FuelType._MAP.GASOLINE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DIESEL () {\n        return FuelType._MAP.DIESEL;\n    }\n\n    /**\n     * For vehicles using compressed natural gas.\n     * @return {String}\n     */\n    static get CNG () {\n        return FuelType._MAP.CNG;\n    }\n\n    /**\n     * For vehicles using liquefied petroleum gas.\n     * @return {String}\n     */\n    static get LPG () {\n        return FuelType._MAP.LPG;\n    }\n\n    /**\n     * For FCEV (fuel cell electric vehicle).\n     * @return {String}\n     */\n    static get HYDROGEN () {\n        return FuelType._MAP.HYDROGEN;\n    }\n\n    /**\n     * For BEV (Battery Electric Vehicle), PHEV (Plug-in Hybrid Electric Vehicle), solar vehicles and other vehicles\n     * which run on a battery.\n     * @return {String}\n     */\n    static get BATTERY () {\n        return FuelType._MAP.BATTERY;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return FuelType._valueForKey(key, FuelType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return FuelType._keyForValue(value, FuelType._MAP);\n    }\n}\n\nFuelType._MAP = Object.freeze({\n    'GASOLINE': 'GASOLINE',\n    'DIESEL': 'DIESEL',\n    'CNG': 'CNG',\n    'LPG': 'LPG',\n    'HYDROGEN': 'HYDROGEN',\n    'BATTERY': 'BATTERY',\n});\n\nexport { FuelType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { FuelType } from '../enums/FuelType.js';\n\nclass FuelRange extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {FuelType} type\n     * @return {FuelRange}\n     */\n    setType (type) {\n        this.validateType(FuelType, type);\n        this.setParameter(FuelRange.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {FuelType}\n     */\n    getType () {\n        return this.getObject(FuelType, FuelRange.KEY_TYPE);\n    }\n\n    /**\n     * @param {Number} range - The estimate range in KM the vehicle can travel based on fuel level and consumption.\n     * @return {FuelRange}\n     */\n    setRange (range) {\n        this.setParameter(FuelRange.KEY_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRange () {\n        return this.getParameter(FuelRange.KEY_RANGE);\n    }\n}\n\nFuelRange.KEY_TYPE = 'type';\nFuelRange.KEY_RANGE = 'range';\n\nexport { FuelRange };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of a vehicle data notification.\n * @typedef {Enum} VehicleDataNotificationStatus\n * @property {Object} _MAP\n */\nclass VehicleDataNotificationStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDNS_NOT_SUPPORTED () {\n        return VehicleDataNotificationStatus._MAP.VDNS_NOT_SUPPORTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDNS_NORMAL () {\n        return VehicleDataNotificationStatus._MAP.VDNS_NORMAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDNS_ACTIVE () {\n        return VehicleDataNotificationStatus._MAP.VDNS_ACTIVE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDNS_NOT_USED () {\n        return VehicleDataNotificationStatus._MAP.VDNS_NOT_USED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VehicleDataNotificationStatus._valueForKey(key, VehicleDataNotificationStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VehicleDataNotificationStatus._keyForValue(value, VehicleDataNotificationStatus._MAP);\n    }\n}\n\nVehicleDataNotificationStatus._MAP = Object.freeze({\n    'VDNS_NOT_SUPPORTED': 'NOT_SUPPORTED',\n    'VDNS_NORMAL': 'NORMAL',\n    'VDNS_ACTIVE': 'ACTIVE',\n    'VDNS_NOT_USED': 'NOT_USED',\n});\n\nexport { VehicleDataNotificationStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of the eCall Notification.\n * @typedef {Enum} ECallConfirmationStatus\n * @property {Object} _MAP\n */\nclass ECallConfirmationStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ECCS_NORMAL () {\n        return ECallConfirmationStatus._MAP.ECCS_NORMAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ECCS_CALL_IN_PROGRESS () {\n        return ECallConfirmationStatus._MAP.ECCS_CALL_IN_PROGRESS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ECCS_CALL_CANCELLED () {\n        return ECallConfirmationStatus._MAP.ECCS_CALL_CANCELLED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CALL_COMPLETED () {\n        return ECallConfirmationStatus._MAP.CALL_COMPLETED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ECCS_CALL_UNSUCCESSFUL () {\n        return ECallConfirmationStatus._MAP.ECCS_CALL_UNSUCCESSFUL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ECCS_ECALL_CONFIGURED_OFF () {\n        return ECallConfirmationStatus._MAP.ECCS_ECALL_CONFIGURED_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ECCS_CALL_COMPLETE_DTMF_TIMEOUT () {\n        return ECallConfirmationStatus._MAP.ECCS_CALL_COMPLETE_DTMF_TIMEOUT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ECallConfirmationStatus._valueForKey(key, ECallConfirmationStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ECallConfirmationStatus._keyForValue(value, ECallConfirmationStatus._MAP);\n    }\n}\n\nECallConfirmationStatus._MAP = Object.freeze({\n    'ECCS_NORMAL': 'NORMAL',\n    'ECCS_CALL_IN_PROGRESS': 'CALL_IN_PROGRESS',\n    'ECCS_CALL_CANCELLED': 'CALL_CANCELLED',\n    'CALL_COMPLETED': 'CALL_COMPLETED',\n    'ECCS_CALL_UNSUCCESSFUL': 'CALL_UNSUCCESSFUL',\n    'ECCS_ECALL_CONFIGURED_OFF': 'ECALL_CONFIGURED_OFF',\n    'ECCS_CALL_COMPLETE_DTMF_TIMEOUT': 'CALL_COMPLETE_DTMF_TIMEOUT',\n});\n\nexport { ECallConfirmationStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VehicleDataNotificationStatus } from '../enums/VehicleDataNotificationStatus.js';\nimport { ECallConfirmationStatus } from '../enums/ECallConfirmationStatus.js';\n\nclass ECallInfo extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {VehicleDataNotificationStatus} status - References signal \"eCallNotification_4A\". See\n     *                                                 VehicleDataNotificationStatus.\n     * @return {ECallInfo}\n     */\n    setECallNotificationStatus (status) {\n        this.validateType(VehicleDataNotificationStatus, status);\n        this.setParameter(ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataNotificationStatus}\n     */\n    getECallNotificationStatus () {\n        return this.getObject(VehicleDataNotificationStatus, ECallInfo.KEY_E_CALL_NOTIFICATION_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataNotificationStatus} status - References signal \"eCallNotification\". See\n     *                                                 VehicleDataNotificationStatus.\n     * @return {ECallInfo}\n     */\n    setAuxECallNotificationStatus (status) {\n        this.validateType(VehicleDataNotificationStatus, status);\n        this.setParameter(ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataNotificationStatus}\n     */\n    getAuxECallNotificationStatus () {\n        return this.getObject(VehicleDataNotificationStatus, ECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS);\n    }\n\n    /**\n     * @param {ECallConfirmationStatus} status - References signal \"eCallConfirmation\". See ECallConfirmationStatus.\n     * @return {ECallInfo}\n     */\n    setECallConfirmationStatus (status) {\n        this.validateType(ECallConfirmationStatus, status);\n        this.setParameter(ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {ECallConfirmationStatus}\n     */\n    getECallConfirmationStatus () {\n        return this.getObject(ECallConfirmationStatus, ECallInfo.KEY_E_CALL_CONFIRMATION_STATUS);\n    }\n}\n\nECallInfo.KEY_E_CALL_NOTIFICATION_STATUS = 'eCallNotificationStatus';\nECallInfo.KEY_AUX_ECALL_NOTIFICATION_STATUS = 'auxECallNotificationStatus';\nECallInfo.KEY_E_CALL_CONFIRMATION_STATUS = 'eCallConfirmationStatus';\n\nexport { ECallInfo };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js';\n\nclass BeltStatus extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsDrvBelt_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setDriverBeltDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(BeltStatus.KEY_DRIVER_BELT_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverBeltDeployed () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_DRIVER_BELT_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsPasBelt_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setPassengerBeltDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(BeltStatus.KEY_PASSENGER_BELT_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getPassengerBeltDeployed () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_BELT_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw1PasBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setPassengerBuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_PASSENGER_BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getPassengerBuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw1DrvBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setDriverBuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_DRIVER_BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverBuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_DRIVER_BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw2lBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setLeftRow2BuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getLeftRow2BuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} detected - References signal \"VedsRw1PasChld_D_Ltchd\". See\n     *                                            VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setPassengerChildDetected (detected) {\n        this.validateType(VehicleDataEventStatus, detected);\n        this.setParameter(BeltStatus.KEY_PASSENGER_CHILD_DETECTED, detected);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getPassengerChildDetected () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_PASSENGER_CHILD_DETECTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw2rBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setRightRow2BuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getRightRow2BuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw2mBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setMiddleRow2BuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getMiddleRow2BuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw3mBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setMiddleRow3BuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getMiddleRow3BuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw3lBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setLeftRow3BuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getLeftRow3BuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw3rBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setRightRow3BuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getRightRow3BuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw2lRib_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setLeftRearInflatableBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getLeftRearInflatableBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw2rRib_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setRightRearInflatableBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getRightRearInflatableBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} deployed - References signal \"VedsRw1mBelt_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setMiddleRow1BeltDeployed (deployed) {\n        this.validateType(VehicleDataEventStatus, deployed);\n        this.setParameter(BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED, deployed);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getMiddleRow1BeltDeployed () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} belted - References signal \"VedsRw1mBckl_D_Ltchd\". See VehicleDataEventStatus.\n     * @return {BeltStatus}\n     */\n    setMiddleRow1BuckleBelted (belted) {\n        this.validateType(VehicleDataEventStatus, belted);\n        this.setParameter(BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED, belted);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getMiddleRow1BuckleBelted () {\n        return this.getObject(VehicleDataEventStatus, BeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED);\n    }\n}\n\nBeltStatus.KEY_DRIVER_BELT_DEPLOYED = 'driverBeltDeployed';\nBeltStatus.KEY_PASSENGER_BELT_DEPLOYED = 'passengerBeltDeployed';\nBeltStatus.KEY_PASSENGER_BUCKLE_BELTED = 'passengerBuckleBelted';\nBeltStatus.KEY_DRIVER_BUCKLE_BELTED = 'driverBuckleBelted';\nBeltStatus.KEY_LEFT_ROW2BUCKLE_BELTED = 'leftRow2BuckleBelted';\nBeltStatus.KEY_PASSENGER_CHILD_DETECTED = 'passengerChildDetected';\nBeltStatus.KEY_RIGHT_ROW2BUCKLE_BELTED = 'rightRow2BuckleBelted';\nBeltStatus.KEY_MIDDLE_ROW2BUCKLE_BELTED = 'middleRow2BuckleBelted';\nBeltStatus.KEY_MIDDLE_ROW3BUCKLE_BELTED = 'middleRow3BuckleBelted';\nBeltStatus.KEY_LEFT_ROW3BUCKLE_BELTED = 'leftRow3BuckleBelted';\nBeltStatus.KEY_RIGHT_ROW3BUCKLE_BELTED = 'rightRow3BuckleBelted';\nBeltStatus.KEY_LEFT_REAR_INFLATABLE_BELTED = 'leftRearInflatableBelted';\nBeltStatus.KEY_RIGHT_REAR_INFLATABLE_BELTED = 'rightRearInflatableBelted';\nBeltStatus.KEY_MIDDLE_ROW1BELT_DEPLOYED = 'middleRow1BeltDeployed';\nBeltStatus.KEY_MIDDLE_ROW1BUCKLE_BELTED = 'middleRow1BuckleBelted';\n\nexport { BeltStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The volume status of a vehicle component.\n * @typedef {Enum} ComponentVolumeStatus\n * @property {Object} _MAP\n */\nclass ComponentVolumeStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CVS_UNKNOWN () {\n        return ComponentVolumeStatus._MAP.CVS_UNKNOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CVS_NORMAL () {\n        return ComponentVolumeStatus._MAP.CVS_NORMAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CVS_LOW () {\n        return ComponentVolumeStatus._MAP.CVS_LOW;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CVS_FAULT () {\n        return ComponentVolumeStatus._MAP.CVS_FAULT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CVS_ALERT () {\n        return ComponentVolumeStatus._MAP.CVS_ALERT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CVS_NOT_SUPPORTED () {\n        return ComponentVolumeStatus._MAP.CVS_NOT_SUPPORTED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ComponentVolumeStatus._valueForKey(key, ComponentVolumeStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ComponentVolumeStatus._keyForValue(value, ComponentVolumeStatus._MAP);\n    }\n}\n\nComponentVolumeStatus._MAP = Object.freeze({\n    'CVS_UNKNOWN': 'UNKNOWN',\n    'CVS_NORMAL': 'NORMAL',\n    'CVS_LOW': 'LOW',\n    'CVS_FAULT': 'FAULT',\n    'CVS_ALERT': 'ALERT',\n    'CVS_NOT_SUPPORTED': 'NOT_SUPPORTED',\n});\n\nexport { ComponentVolumeStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of ignition.\n * @typedef {Enum} IgnitionStatus\n * @property {Object} _MAP\n */\nclass IgnitionStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IS_UNKNOWN () {\n        return IgnitionStatus._MAP.IS_UNKNOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IS_OFF () {\n        return IgnitionStatus._MAP.IS_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IS_ACCESSORY () {\n        return IgnitionStatus._MAP.IS_ACCESSORY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IS_RUN () {\n        return IgnitionStatus._MAP.IS_RUN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IS_START () {\n        return IgnitionStatus._MAP.IS_START;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IS_INVALID () {\n        return IgnitionStatus._MAP.IS_INVALID;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return IgnitionStatus._valueForKey(key, IgnitionStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return IgnitionStatus._keyForValue(value, IgnitionStatus._MAP);\n    }\n}\n\nIgnitionStatus._MAP = Object.freeze({\n    'IS_UNKNOWN': 'UNKNOWN',\n    'IS_OFF': 'OFF',\n    'IS_ACCESSORY': 'ACCESSORY',\n    'IS_RUN': 'RUN',\n    'IS_START': 'START',\n    'IS_INVALID': 'INVALID',\n});\n\nexport { IgnitionStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the ignition switch stability.\n * @typedef {Enum} IgnitionStableStatus\n * @property {Object} _MAP\n */\nclass IgnitionStableStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IGNITION_SWITCH_NOT_STABLE () {\n        return IgnitionStableStatus._MAP.IGNITION_SWITCH_NOT_STABLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IGNITION_SWITCH_STABLE () {\n        return IgnitionStableStatus._MAP.IGNITION_SWITCH_STABLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MISSING_FROM_TRANSMITTER () {\n        return IgnitionStableStatus._MAP.MISSING_FROM_TRANSMITTER;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return IgnitionStableStatus._valueForKey(key, IgnitionStableStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return IgnitionStableStatus._keyForValue(value, IgnitionStableStatus._MAP);\n    }\n}\n\nIgnitionStableStatus._MAP = Object.freeze({\n    'IGNITION_SWITCH_NOT_STABLE': 'IGNITION_SWITCH_NOT_STABLE',\n    'IGNITION_SWITCH_STABLE': 'IGNITION_SWITCH_STABLE',\n    'MISSING_FROM_TRANSMITTER': 'MISSING_FROM_TRANSMITTER',\n});\n\nexport { IgnitionStableStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { IgnitionStatus } from '../enums/IgnitionStatus.js';\nimport { IgnitionStableStatus } from '../enums/IgnitionStableStatus.js';\n\nclass BodyInformation extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} active - References signal \"PrkBrkActv_B_Actl\".\n     * @return {BodyInformation}\n     */\n    setParkBrakeActive (active) {\n        this.setParameter(BodyInformation.KEY_PARK_BRAKE_ACTIVE, active);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getParkBrakeActive () {\n        return this.getParameter(BodyInformation.KEY_PARK_BRAKE_ACTIVE);\n    }\n\n    /**\n     * @param {IgnitionStableStatus} status - References signal \"Ignition_Switch_Stable\". See IgnitionStableStatus.\n     * @return {BodyInformation}\n     */\n    setIgnitionStableStatus (status) {\n        this.validateType(IgnitionStableStatus, status);\n        this.setParameter(BodyInformation.KEY_IGNITION_STABLE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {IgnitionStableStatus}\n     */\n    getIgnitionStableStatus () {\n        return this.getObject(IgnitionStableStatus, BodyInformation.KEY_IGNITION_STABLE_STATUS);\n    }\n\n    /**\n     * @param {IgnitionStatus} status - References signal \"Ignition_status\". See IgnitionStatus.\n     * @return {BodyInformation}\n     */\n    setIgnitionStatus (status) {\n        this.validateType(IgnitionStatus, status);\n        this.setParameter(BodyInformation.KEY_IGNITION_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {IgnitionStatus}\n     */\n    getIgnitionStatus () {\n        return this.getObject(IgnitionStatus, BodyInformation.KEY_IGNITION_STATUS);\n    }\n\n    /**\n     * @param {Boolean} ajar - References signal \"DrStatDrv_B_Actl\".\n     * @return {BodyInformation}\n     */\n    setDriverDoorAjar (ajar) {\n        this.setParameter(BodyInformation.KEY_DRIVER_DOOR_AJAR, ajar);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDriverDoorAjar () {\n        return this.getParameter(BodyInformation.KEY_DRIVER_DOOR_AJAR);\n    }\n\n    /**\n     * @param {Boolean} ajar - References signal \"DrStatPsngr_B_Actl\".\n     * @return {BodyInformation}\n     */\n    setPassengerDoorAjar (ajar) {\n        this.setParameter(BodyInformation.KEY_PASSENGER_DOOR_AJAR, ajar);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPassengerDoorAjar () {\n        return this.getParameter(BodyInformation.KEY_PASSENGER_DOOR_AJAR);\n    }\n\n    /**\n     * @param {Boolean} ajar - References signal \"DrStatRl_B_Actl\".\n     * @return {BodyInformation}\n     */\n    setRearLeftDoorAjar (ajar) {\n        this.setParameter(BodyInformation.KEY_REAR_LEFT_DOOR_AJAR, ajar);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRearLeftDoorAjar () {\n        return this.getParameter(BodyInformation.KEY_REAR_LEFT_DOOR_AJAR);\n    }\n\n    /**\n     * @param {Boolean} ajar - References signal \"DrStatRr_B_Actl\".\n     * @return {BodyInformation}\n     */\n    setRearRightDoorAjar (ajar) {\n        this.setParameter(BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR, ajar);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRearRightDoorAjar () {\n        return this.getParameter(BodyInformation.KEY_REAR_RIGHT_DOOR_AJAR);\n    }\n}\n\nBodyInformation.KEY_PARK_BRAKE_ACTIVE = 'parkBrakeActive';\nBodyInformation.KEY_IGNITION_STABLE_STATUS = 'ignitionStableStatus';\nBodyInformation.KEY_IGNITION_STATUS = 'ignitionStatus';\nBodyInformation.KEY_DRIVER_DOOR_AJAR = 'driverDoorAjar';\nBodyInformation.KEY_PASSENGER_DOOR_AJAR = 'passengerDoorAjar';\nBodyInformation.KEY_REAR_LEFT_DOOR_AJAR = 'rearLeftDoorAjar';\nBodyInformation.KEY_REAR_RIGHT_DOOR_AJAR = 'rearRightDoorAjar';\n\nexport { BodyInformation };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TPMS\n * @property {Object} _MAP\n */\nclass TPMS extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * If set the status of the tire is not known.\n     * @return {String}\n     */\n    static get UNKNOWN () {\n        return TPMS._MAP.UNKNOWN;\n    }\n\n    /**\n     * TPMS does not function.\n     * @return {String}\n     */\n    static get SYSTEM_FAULT () {\n        return TPMS._MAP.SYSTEM_FAULT;\n    }\n\n    /**\n     * The sensor of the tire does not function.\n     * @return {String}\n     */\n    static get SENSOR_FAULT () {\n        return TPMS._MAP.SENSOR_FAULT;\n    }\n\n    /**\n     * TPMS is reporting a low tire pressure for the tire.\n     * @return {String}\n     */\n    static get LOW () {\n        return TPMS._MAP.LOW;\n    }\n\n    /**\n     * TPMS is active and the tire pressure is monitored.\n     * @return {String}\n     */\n    static get SYSTEM_ACTIVE () {\n        return TPMS._MAP.SYSTEM_ACTIVE;\n    }\n\n    /**\n     * TPMS is reporting that the tire must be trained.\n     * @return {String}\n     */\n    static get TRAIN () {\n        return TPMS._MAP.TRAIN;\n    }\n\n    /**\n     * TPMS reports the training for the tire is completed.\n     * @return {String}\n     */\n    static get TRAINING_COMPLETE () {\n        return TPMS._MAP.TRAINING_COMPLETE;\n    }\n\n    /**\n     * TPMS reports the tire is not trained.\n     * @return {String}\n     */\n    static get NOT_TRAINED () {\n        return TPMS._MAP.NOT_TRAINED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TPMS._valueForKey(key, TPMS._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TPMS._keyForValue(value, TPMS._MAP);\n    }\n}\n\nTPMS._MAP = Object.freeze({\n    'UNKNOWN': 'UNKNOWN',\n    'SYSTEM_FAULT': 'SYSTEM_FAULT',\n    'SENSOR_FAULT': 'SENSOR_FAULT',\n    'LOW': 'LOW',\n    'SYSTEM_ACTIVE': 'SYSTEM_ACTIVE',\n    'TRAIN': 'TRAIN',\n    'TRAINING_COMPLETE': 'TRAINING_COMPLETE',\n    'NOT_TRAINED': 'NOT_TRAINED',\n});\n\nexport { TPMS };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ComponentVolumeStatus } from '../enums/ComponentVolumeStatus.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { TPMS } from '../enums/TPMS.js';\n\nclass SingleTireStatus extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ComponentVolumeStatus} status - See ComponentVolumeStatus.\n     * @return {SingleTireStatus}\n     */\n    setStatus (status) {\n        this.validateType(ComponentVolumeStatus, status);\n        this.setParameter(SingleTireStatus.KEY_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {ComponentVolumeStatus}\n     */\n    getStatus () {\n        return this.getObject(ComponentVolumeStatus, SingleTireStatus.KEY_STATUS);\n    }\n\n    /**\n     * @param {TPMS} tpms - The status of TPMS according to the particular tire.\n     * @return {SingleTireStatus}\n     */\n    setTpms (tpms) {\n        this.validateType(TPMS, tpms);\n        this.setParameter(SingleTireStatus.KEY_TPMS, tpms);\n        return this;\n    }\n\n    /**\n     * @return {TPMS}\n     */\n    getTpms () {\n        return this.getObject(TPMS, SingleTireStatus.KEY_TPMS);\n    }\n\n    /**\n     * @param {Number} pressure - The pressure value of the particular tire in kilo pascal.\n     * @return {SingleTireStatus}\n     */\n    setPressure (pressure) {\n        this.setParameter(SingleTireStatus.KEY_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPressure () {\n        return this.getParameter(SingleTireStatus.KEY_PRESSURE);\n    }\n}\n\nSingleTireStatus.KEY_STATUS = 'status';\nSingleTireStatus.KEY_TPMS = 'tpms';\nSingleTireStatus.KEY_PRESSURE = 'pressure';\n\nexport { SingleTireStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of a cluster instrument warning light.\n * @typedef {Enum} WarningLightStatus\n * @property {Object} _MAP\n */\nclass WarningLightStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WLS_OFF () {\n        return WarningLightStatus._MAP.WLS_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WLS_ON () {\n        return WarningLightStatus._MAP.WLS_ON;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WLS_FLASH () {\n        return WarningLightStatus._MAP.WLS_FLASH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WLS_NOT_USED () {\n        return WarningLightStatus._MAP.WLS_NOT_USED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return WarningLightStatus._valueForKey(key, WarningLightStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return WarningLightStatus._keyForValue(value, WarningLightStatus._MAP);\n    }\n}\n\nWarningLightStatus._MAP = Object.freeze({\n    'WLS_OFF': 'OFF',\n    'WLS_ON': 'ON',\n    'WLS_FLASH': 'FLASH',\n    'WLS_NOT_USED': 'NOT_USED',\n});\n\nexport { WarningLightStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SingleTireStatus } from './SingleTireStatus.js';\nimport { WarningLightStatus } from '../enums/WarningLightStatus.js';\n\n/**\n * The status and pressure of the tires.\n */\nclass TireStatus extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {WarningLightStatus} telltale - Status of the Tire Pressure Telltale. See WarningLightStatus.\n     * @return {TireStatus}\n     */\n    setPressureTelltale (telltale) {\n        this.validateType(WarningLightStatus, telltale);\n        this.setParameter(TireStatus.KEY_PRESSURE_TELLTALE, telltale);\n        return this;\n    }\n\n    /**\n     * @return {WarningLightStatus}\n     */\n    getPressureTelltale () {\n        return this.getObject(WarningLightStatus, TireStatus.KEY_PRESSURE_TELLTALE);\n    }\n\n    /**\n     * @param {SingleTireStatus} front - The status of the left front tire.\n     * @return {TireStatus}\n     */\n    setLeftFront (front) {\n        this.validateType(SingleTireStatus, front);\n        this.setParameter(TireStatus.KEY_LEFT_FRONT, front);\n        return this;\n    }\n\n    /**\n     * @return {SingleTireStatus}\n     */\n    getLeftFront () {\n        return this.getObject(SingleTireStatus, TireStatus.KEY_LEFT_FRONT);\n    }\n\n    /**\n     * @param {SingleTireStatus} front - The status of the right front tire.\n     * @return {TireStatus}\n     */\n    setRightFront (front) {\n        this.validateType(SingleTireStatus, front);\n        this.setParameter(TireStatus.KEY_RIGHT_FRONT, front);\n        return this;\n    }\n\n    /**\n     * @return {SingleTireStatus}\n     */\n    getRightFront () {\n        return this.getObject(SingleTireStatus, TireStatus.KEY_RIGHT_FRONT);\n    }\n\n    /**\n     * @param {SingleTireStatus} rear - The status of the left rear tire.\n     * @return {TireStatus}\n     */\n    setLeftRear (rear) {\n        this.validateType(SingleTireStatus, rear);\n        this.setParameter(TireStatus.KEY_LEFT_REAR, rear);\n        return this;\n    }\n\n    /**\n     * @return {SingleTireStatus}\n     */\n    getLeftRear () {\n        return this.getObject(SingleTireStatus, TireStatus.KEY_LEFT_REAR);\n    }\n\n    /**\n     * @param {SingleTireStatus} rear - The status of the right rear tire.\n     * @return {TireStatus}\n     */\n    setRightRear (rear) {\n        this.validateType(SingleTireStatus, rear);\n        this.setParameter(TireStatus.KEY_RIGHT_REAR, rear);\n        return this;\n    }\n\n    /**\n     * @return {SingleTireStatus}\n     */\n    getRightRear () {\n        return this.getObject(SingleTireStatus, TireStatus.KEY_RIGHT_REAR);\n    }\n\n    /**\n     * @param {SingleTireStatus} rear - The status of the inner left rear.\n     * @return {TireStatus}\n     */\n    setInnerLeftRear (rear) {\n        this.validateType(SingleTireStatus, rear);\n        this.setParameter(TireStatus.KEY_INNER_LEFT_REAR, rear);\n        return this;\n    }\n\n    /**\n     * @return {SingleTireStatus}\n     */\n    getInnerLeftRear () {\n        return this.getObject(SingleTireStatus, TireStatus.KEY_INNER_LEFT_REAR);\n    }\n\n    /**\n     * @param {SingleTireStatus} rear - The status of the inner right rear.\n     * @return {TireStatus}\n     */\n    setInnerRightRear (rear) {\n        this.validateType(SingleTireStatus, rear);\n        this.setParameter(TireStatus.KEY_INNER_RIGHT_REAR, rear);\n        return this;\n    }\n\n    /**\n     * @return {SingleTireStatus}\n     */\n    getInnerRightRear () {\n        return this.getObject(SingleTireStatus, TireStatus.KEY_INNER_RIGHT_REAR);\n    }\n}\n\nTireStatus.KEY_PRESSURE_TELLTALE = 'pressureTelltale';\nTireStatus.KEY_LEFT_FRONT = 'leftFront';\nTireStatus.KEY_RIGHT_FRONT = 'rightFront';\nTireStatus.KEY_LEFT_REAR = 'leftRear';\nTireStatus.KEY_RIGHT_REAR = 'rightRear';\nTireStatus.KEY_INNER_LEFT_REAR = 'innerLeftRear';\nTireStatus.KEY_INNER_RIGHT_REAR = 'innerRightRear';\n\nexport { TireStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { AirbagStatus } from '../structs/AirbagStatus.js';\nimport { ClusterModeStatus } from '../structs/ClusterModeStatus.js';\nimport { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js';\nimport { EmergencyEvent } from '../structs/EmergencyEvent.js';\nimport { TurnSignal } from '../enums/TurnSignal.js';\nimport { RpcResponse } from '../RpcResponse.js';\nimport { HeadLampStatus } from '../structs/HeadLampStatus.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { DeviceStatus } from '../structs/DeviceStatus.js';\nimport { WiperStatus } from '../enums/WiperStatus.js';\nimport { ElectronicParkBrakeStatus } from '../enums/ElectronicParkBrakeStatus.js';\nimport { MyKey } from '../structs/MyKey.js';\nimport { GPSData } from '../structs/GPSData.js';\nimport { PRNDL } from '../enums/PRNDL.js';\nimport { FuelRange } from '../structs/FuelRange.js';\nimport { ECallInfo } from '../structs/ECallInfo.js';\nimport { BeltStatus } from '../structs/BeltStatus.js';\nimport { ComponentVolumeStatus } from '../enums/ComponentVolumeStatus.js';\nimport { BodyInformation } from '../structs/BodyInformation.js';\nimport { TireStatus } from '../structs/TireStatus.js';\n\nclass GetVehicleDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetVehicleData);\n    }\n\n    /**\n     * @param {GPSData} gps - See GPSData\n     * @return {GetVehicleDataResponse}\n     */\n    setGps (gps) {\n        this.validateType(GPSData, gps);\n        this.setParameter(GetVehicleDataResponse.KEY_GPS, gps);\n        return this;\n    }\n\n    /**\n     * @return {GPSData}\n     */\n    getGps () {\n        return this.getObject(GPSData, GetVehicleDataResponse.KEY_GPS);\n    }\n\n    /**\n     * @param {Number} speed - The vehicle speed in kilometers per hour\n     * @return {GetVehicleDataResponse}\n     */\n    setSpeed (speed) {\n        this.setParameter(GetVehicleDataResponse.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSpeed () {\n        return this.getParameter(GetVehicleDataResponse.KEY_SPEED);\n    }\n\n    /**\n     * @param {Number} rpm - The number of revolutions per minute of the engine\n     * @return {GetVehicleDataResponse}\n     */\n    setRpm (rpm) {\n        this.setParameter(GetVehicleDataResponse.KEY_RPM, rpm);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRpm () {\n        return this.getParameter(GetVehicleDataResponse.KEY_RPM);\n    }\n\n    /**\n     * @param {Number} level - The fuel level in the tank (percentage)\n     * @return {GetVehicleDataResponse}\n     */\n    setFuelLevel (level) {\n        this.setParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFuelLevel () {\n        return this.getParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL);\n    }\n\n    /**\n     * @param {ComponentVolumeStatus} level_state - The fuel level state\n     * @return {GetVehicleDataResponse}\n     */\n    setFuelLevel_State (level_state) {\n        this.validateType(ComponentVolumeStatus, level_state);\n        this.setParameter(GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE, level_state);\n        return this;\n    }\n\n    /**\n     * @return {ComponentVolumeStatus}\n     */\n    getFuelLevel_State () {\n        return this.getObject(ComponentVolumeStatus, GetVehicleDataResponse.KEY_FUEL_LEVEL_STATE);\n    }\n\n    /**\n     * @param {Number} consumption - The instantaneous fuel consumption in microlitres\n     * @return {GetVehicleDataResponse}\n     */\n    setInstantFuelConsumption (consumption) {\n        this.setParameter(GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION, consumption);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getInstantFuelConsumption () {\n        return this.getParameter(GetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION);\n    }\n\n    /**\n     * @param {FuelRange[]} range - The estimate range in KM the vehicle can travel based on fuel level and consumption\n     * @return {GetVehicleDataResponse}\n     */\n    setFuelRange (range) {\n        this.validateType(FuelRange, range, true);\n        this.setParameter(GetVehicleDataResponse.KEY_FUEL_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {FuelRange[]}\n     */\n    getFuelRange () {\n        return this.getObject(FuelRange, GetVehicleDataResponse.KEY_FUEL_RANGE);\n    }\n\n    /**\n     * @param {Number} temperature - The external temperature in degrees celsius\n     * @return {GetVehicleDataResponse}\n     */\n    setExternalTemperature (temperature) {\n        this.setParameter(GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getExternalTemperature () {\n        return this.getParameter(GetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE);\n    }\n\n    /**\n     * @param {TurnSignal} signal - See TurnSignal\n     * @return {GetVehicleDataResponse}\n     */\n    setTurnSignal (signal) {\n        this.validateType(TurnSignal, signal);\n        this.setParameter(GetVehicleDataResponse.KEY_TURN_SIGNAL, signal);\n        return this;\n    }\n\n    /**\n     * @return {TurnSignal}\n     */\n    getTurnSignal () {\n        return this.getObject(TurnSignal, GetVehicleDataResponse.KEY_TURN_SIGNAL);\n    }\n\n    /**\n     * @param {String} vin - Vehicle identification number\n     * @return {GetVehicleDataResponse}\n     */\n    setVin (vin) {\n        this.setParameter(GetVehicleDataResponse.KEY_VIN, vin);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getVin () {\n        return this.getParameter(GetVehicleDataResponse.KEY_VIN);\n    }\n\n    /**\n     * @param {PRNDL} prndl - See PRNDL\n     * @return {GetVehicleDataResponse}\n     */\n    setPrndl (prndl) {\n        this.validateType(PRNDL, prndl);\n        this.setParameter(GetVehicleDataResponse.KEY_PRNDL, prndl);\n        return this;\n    }\n\n    /**\n     * @return {PRNDL}\n     */\n    getPrndl () {\n        return this.getObject(PRNDL, GetVehicleDataResponse.KEY_PRNDL);\n    }\n\n    /**\n     * @param {TireStatus} pressure - See TireStatus\n     * @return {GetVehicleDataResponse}\n     */\n    setTirePressure (pressure) {\n        this.validateType(TireStatus, pressure);\n        this.setParameter(GetVehicleDataResponse.KEY_TIRE_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {TireStatus}\n     */\n    getTirePressure () {\n        return this.getObject(TireStatus, GetVehicleDataResponse.KEY_TIRE_PRESSURE);\n    }\n\n    /**\n     * @param {Number} odometer - Odometer in km\n     * @return {GetVehicleDataResponse}\n     */\n    setOdometer (odometer) {\n        this.setParameter(GetVehicleDataResponse.KEY_ODOMETER, odometer);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getOdometer () {\n        return this.getParameter(GetVehicleDataResponse.KEY_ODOMETER);\n    }\n\n    /**\n     * @param {BeltStatus} status - The status of the seat belts\n     * @return {GetVehicleDataResponse}\n     */\n    setBeltStatus (status) {\n        this.validateType(BeltStatus, status);\n        this.setParameter(GetVehicleDataResponse.KEY_BELT_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {BeltStatus}\n     */\n    getBeltStatus () {\n        return this.getObject(BeltStatus, GetVehicleDataResponse.KEY_BELT_STATUS);\n    }\n\n    /**\n     * @param {BodyInformation} information - The body information including power modes\n     * @return {GetVehicleDataResponse}\n     */\n    setBodyInformation (information) {\n        this.validateType(BodyInformation, information);\n        this.setParameter(GetVehicleDataResponse.KEY_BODY_INFORMATION, information);\n        return this;\n    }\n\n    /**\n     * @return {BodyInformation}\n     */\n    getBodyInformation () {\n        return this.getObject(BodyInformation, GetVehicleDataResponse.KEY_BODY_INFORMATION);\n    }\n\n    /**\n     * @param {DeviceStatus} status - The device status including signal and battery strength\n     * @return {GetVehicleDataResponse}\n     */\n    setDeviceStatus (status) {\n        this.validateType(DeviceStatus, status);\n        this.setParameter(GetVehicleDataResponse.KEY_DEVICE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {DeviceStatus}\n     */\n    getDeviceStatus () {\n        return this.getObject(DeviceStatus, GetVehicleDataResponse.KEY_DEVICE_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} braking - The status of the brake pedal\n     * @return {GetVehicleDataResponse}\n     */\n    setDriverBraking (braking) {\n        this.validateType(VehicleDataEventStatus, braking);\n        this.setParameter(GetVehicleDataResponse.KEY_DRIVER_BRAKING, braking);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverBraking () {\n        return this.getObject(VehicleDataEventStatus, GetVehicleDataResponse.KEY_DRIVER_BRAKING);\n    }\n\n    /**\n     * @param {WiperStatus} status - The status of the wipers\n     * @return {GetVehicleDataResponse}\n     */\n    setWiperStatus (status) {\n        this.validateType(WiperStatus, status);\n        this.setParameter(GetVehicleDataResponse.KEY_WIPER_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {WiperStatus}\n     */\n    getWiperStatus () {\n        return this.getObject(WiperStatus, GetVehicleDataResponse.KEY_WIPER_STATUS);\n    }\n\n    /**\n     * @param {HeadLampStatus} status - Status of the head lamps\n     * @return {GetVehicleDataResponse}\n     */\n    setHeadLampStatus (status) {\n        this.validateType(HeadLampStatus, status);\n        this.setParameter(GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {HeadLampStatus}\n     */\n    getHeadLampStatus () {\n        return this.getObject(HeadLampStatus, GetVehicleDataResponse.KEY_HEAD_LAMP_STATUS);\n    }\n\n    /**\n     * @param {Number} torque - Torque value for engine (in Nm) on non-diesel variants\n     * @return {GetVehicleDataResponse}\n     */\n    setEngineTorque (torque) {\n        this.setParameter(GetVehicleDataResponse.KEY_ENGINE_TORQUE, torque);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEngineTorque () {\n        return this.getParameter(GetVehicleDataResponse.KEY_ENGINE_TORQUE);\n    }\n\n    /**\n     * @param {Number} position - Accelerator pedal position (percentage depressed)\n     * @return {GetVehicleDataResponse}\n     */\n    setAccPedalPosition (position) {\n        this.setParameter(GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getAccPedalPosition () {\n        return this.getParameter(GetVehicleDataResponse.KEY_ACC_PEDAL_POSITION);\n    }\n\n    /**\n     * @param {Number} angle - Current angle of the steering wheel (in deg)\n     * @return {GetVehicleDataResponse}\n     */\n    setSteeringWheelAngle (angle) {\n        this.setParameter(GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSteeringWheelAngle () {\n        return this.getParameter(GetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE);\n    }\n\n    /**\n     * @param {Number} life - The estimated percentage of remaining oil life of the engine.\n     * @return {GetVehicleDataResponse}\n     */\n    setEngineOilLife (life) {\n        this.setParameter(GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE, life);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEngineOilLife () {\n        return this.getParameter(GetVehicleDataResponse.KEY_ENGINE_OIL_LIFE);\n    }\n\n    /**\n     * @param {ElectronicParkBrakeStatus} status - The status of the park brake as provided by Electric Park Brake (EPB)\n     *                                             system.\n     * @return {GetVehicleDataResponse}\n     */\n    setElectronicParkBrakeStatus (status) {\n        this.validateType(ElectronicParkBrakeStatus, status);\n        this.setParameter(GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {ElectronicParkBrakeStatus}\n     */\n    getElectronicParkBrakeStatus () {\n        return this.getObject(ElectronicParkBrakeStatus, GetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS);\n    }\n\n    /**\n     * @param {String} id - Parameter used by cloud apps to identify a head unit\n     * @return {GetVehicleDataResponse}\n     */\n    setCloudAppVehicleID (id) {\n        this.setParameter(GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getCloudAppVehicleID () {\n        return this.getParameter(GetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID);\n    }\n\n    /**\n     * @param {ECallInfo} info - Emergency Call notification and confirmation data\n     * @return {GetVehicleDataResponse}\n     */\n    setECallInfo (info) {\n        this.validateType(ECallInfo, info);\n        this.setParameter(GetVehicleDataResponse.KEY_E_CALL_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ECallInfo}\n     */\n    getECallInfo () {\n        return this.getObject(ECallInfo, GetVehicleDataResponse.KEY_E_CALL_INFO);\n    }\n\n    /**\n     * @param {AirbagStatus} status - The status of the air bags\n     * @return {GetVehicleDataResponse}\n     */\n    setAirbagStatus (status) {\n        this.validateType(AirbagStatus, status);\n        this.setParameter(GetVehicleDataResponse.KEY_AIRBAG_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {AirbagStatus}\n     */\n    getAirbagStatus () {\n        return this.getObject(AirbagStatus, GetVehicleDataResponse.KEY_AIRBAG_STATUS);\n    }\n\n    /**\n     * @param {EmergencyEvent} event - Information related to an emergency event (and if it occurred)\n     * @return {GetVehicleDataResponse}\n     */\n    setEmergencyEvent (event) {\n        this.validateType(EmergencyEvent, event);\n        this.setParameter(GetVehicleDataResponse.KEY_EMERGENCY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {EmergencyEvent}\n     */\n    getEmergencyEvent () {\n        return this.getObject(EmergencyEvent, GetVehicleDataResponse.KEY_EMERGENCY_EVENT);\n    }\n\n    /**\n     * @param {ClusterModeStatus} status - The status modes of the cluster\n     * @return {GetVehicleDataResponse}\n     */\n    setClusterModeStatus (status) {\n        this.validateType(ClusterModeStatus, status);\n        this.setParameter(GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {ClusterModeStatus}\n     */\n    getClusterModeStatus () {\n        return this.getObject(ClusterModeStatus, GetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS);\n    }\n\n    /**\n     * @param {MyKey} key - Information related to the MyKey feature\n     * @return {GetVehicleDataResponse}\n     */\n    setMyKey (key) {\n        this.validateType(MyKey, key);\n        this.setParameter(GetVehicleDataResponse.KEY_MY_KEY, key);\n        return this;\n    }\n\n    /**\n     * @return {MyKey}\n     */\n    getMyKey () {\n        return this.getObject(MyKey, GetVehicleDataResponse.KEY_MY_KEY);\n    }\n}\n\nGetVehicleDataResponse.KEY_GPS = 'gps';\nGetVehicleDataResponse.KEY_SPEED = 'speed';\nGetVehicleDataResponse.KEY_RPM = 'rpm';\nGetVehicleDataResponse.KEY_FUEL_LEVEL = 'fuelLevel';\nGetVehicleDataResponse.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State';\nGetVehicleDataResponse.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption';\nGetVehicleDataResponse.KEY_FUEL_RANGE = 'fuelRange';\nGetVehicleDataResponse.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature';\nGetVehicleDataResponse.KEY_TURN_SIGNAL = 'turnSignal';\nGetVehicleDataResponse.KEY_VIN = 'vin';\nGetVehicleDataResponse.KEY_PRNDL = 'prndl';\nGetVehicleDataResponse.KEY_TIRE_PRESSURE = 'tirePressure';\nGetVehicleDataResponse.KEY_ODOMETER = 'odometer';\nGetVehicleDataResponse.KEY_BELT_STATUS = 'beltStatus';\nGetVehicleDataResponse.KEY_BODY_INFORMATION = 'bodyInformation';\nGetVehicleDataResponse.KEY_DEVICE_STATUS = 'deviceStatus';\nGetVehicleDataResponse.KEY_DRIVER_BRAKING = 'driverBraking';\nGetVehicleDataResponse.KEY_WIPER_STATUS = 'wiperStatus';\nGetVehicleDataResponse.KEY_HEAD_LAMP_STATUS = 'headLampStatus';\nGetVehicleDataResponse.KEY_ENGINE_TORQUE = 'engineTorque';\nGetVehicleDataResponse.KEY_ACC_PEDAL_POSITION = 'accPedalPosition';\nGetVehicleDataResponse.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle';\nGetVehicleDataResponse.KEY_ENGINE_OIL_LIFE = 'engineOilLife';\nGetVehicleDataResponse.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus';\nGetVehicleDataResponse.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID';\nGetVehicleDataResponse.KEY_E_CALL_INFO = 'eCallInfo';\nGetVehicleDataResponse.KEY_AIRBAG_STATUS = 'airbagStatus';\nGetVehicleDataResponse.KEY_EMERGENCY_EVENT = 'emergencyEvent';\nGetVehicleDataResponse.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus';\nGetVehicleDataResponse.KEY_MY_KEY = 'myKey';\n\nexport { GetVehicleDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Non periodic vehicle data read request\n */\nclass ReadDID extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ReadDID);\n    }\n\n    /**\n     * @param {Number} name - Name of ECU.\n     * @return {ReadDID}\n     */\n    setEcuName (name) {\n        this.setParameter(ReadDID.KEY_ECU_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEcuName () {\n        return this.getParameter(ReadDID.KEY_ECU_NAME);\n    }\n\n    /**\n     * @param {Number[]} location - Get raw data from vehicle data DID location(s)\n     * @return {ReadDID}\n     */\n    setDidLocation (location) {\n        this.setParameter(ReadDID.KEY_DID_LOCATION, location);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getDidLocation () {\n        return this.getParameter(ReadDID.KEY_DID_LOCATION);\n    }\n}\n\nReadDID.KEY_ECU_NAME = 'ecuName';\nReadDID.KEY_DID_LOCATION = 'didLocation';\n\nexport { ReadDID };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VehicleDataResultCode } from '../enums/VehicleDataResultCode.js';\n\n/**\n * Individual requested DID result and data\n */\nclass DIDResult extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {VehicleDataResultCode} code - Individual DID result code.\n     * @return {DIDResult}\n     */\n    setResultCode (code) {\n        this.validateType(VehicleDataResultCode, code);\n        this.setParameter(DIDResult.KEY_RESULT_CODE, code);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataResultCode}\n     */\n    getResultCode () {\n        return this.getObject(VehicleDataResultCode, DIDResult.KEY_RESULT_CODE);\n    }\n\n    /**\n     * @param {Number} location - Location of raw data from vehicle data DID\n     * @return {DIDResult}\n     */\n    setDidLocation (location) {\n        this.setParameter(DIDResult.KEY_DID_LOCATION, location);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDidLocation () {\n        return this.getParameter(DIDResult.KEY_DID_LOCATION);\n    }\n\n    /**\n     * @param {String} data - Raw DID-based data returned for requested element.\n     * @return {DIDResult}\n     */\n    setData (data) {\n        this.setParameter(DIDResult.KEY_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getData () {\n        return this.getParameter(DIDResult.KEY_DATA);\n    }\n}\n\nDIDResult.KEY_RESULT_CODE = 'resultCode';\nDIDResult.KEY_DID_LOCATION = 'didLocation';\nDIDResult.KEY_DATA = 'data';\n\nexport { DIDResult };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { DIDResult } from '../structs/DIDResult.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ReadDIDResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ReadDID);\n    }\n\n    /**\n     * @param {DIDResult[]} result - Array of requested DID results (with data if available).\n     * @return {ReadDIDResponse}\n     */\n    setDidResult (result) {\n        this.validateType(DIDResult, result, true);\n        this.setParameter(ReadDIDResponse.KEY_DID_RESULT, result);\n        return this;\n    }\n\n    /**\n     * @return {DIDResult[]}\n     */\n    getDidResult () {\n        return this.getObject(DIDResult, ReadDIDResponse.KEY_DID_RESULT);\n    }\n}\n\nReadDIDResponse.KEY_DID_RESULT = 'didResult';\n\nexport { ReadDIDResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Vehicle module diagnostic trouble code request.\n */\nclass GetDTCs extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetDTCs);\n    }\n\n    /**\n     * @param {Number} name - Name of ECU.\n     * @return {GetDTCs}\n     */\n    setEcuName (name) {\n        this.setParameter(GetDTCs.KEY_ECU_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEcuName () {\n        return this.getParameter(GetDTCs.KEY_ECU_NAME);\n    }\n\n    /**\n     * @param {Number} mask - DTC Mask Byte to be sent in diagnostic request to module .\n     * @return {GetDTCs}\n     */\n    setDtcMask (mask) {\n        this.setParameter(GetDTCs.KEY_DTC_MASK, mask);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDtcMask () {\n        return this.getParameter(GetDTCs.KEY_DTC_MASK);\n    }\n}\n\nGetDTCs.KEY_ECU_NAME = 'ecuName';\nGetDTCs.KEY_DTC_MASK = 'dtcMask';\n\nexport { GetDTCs };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass GetDTCsResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetDTCs);\n    }\n\n    /**\n     * @param {Number} header - 2 byte ECU Header for DTC response (as defined in VHR_Layout_Specification_DTCs.pdf)\n     * @return {GetDTCsResponse}\n     */\n    setEcuHeader (header) {\n        this.setParameter(GetDTCsResponse.KEY_ECU_HEADER, header);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEcuHeader () {\n        return this.getParameter(GetDTCsResponse.KEY_ECU_HEADER);\n    }\n\n    /**\n     * @param {String[]} dtc - Array of all reported DTCs on module (ecuHeader contains information if list is\n     *                         truncated). Each DTC is represented by 4 bytes (3 bytes of data and 1 byte status as\n     *                         defined in VHR_Layout_Specification_DTCs.pdf).\n     * @return {GetDTCsResponse}\n     */\n    setDtc (dtc) {\n        this.setParameter(GetDTCsResponse.KEY_DTC, dtc);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getDtc () {\n        return this.getParameter(GetDTCsResponse.KEY_DTC);\n    }\n}\n\nGetDTCsResponse.KEY_ECU_HEADER = 'ecuHeader';\nGetDTCsResponse.KEY_DTC = 'dtc';\n\nexport { GetDTCsResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Non periodic vehicle diagnostic request\n */\nclass DiagnosticMessage extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DiagnosticMessage);\n    }\n\n    /**\n     * @param {Number} id - Name of target ECU.\n     * @return {DiagnosticMessage}\n     */\n    setTargetID (id) {\n        this.setParameter(DiagnosticMessage.KEY_TARGET_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTargetID () {\n        return this.getParameter(DiagnosticMessage.KEY_TARGET_ID);\n    }\n\n    /**\n     * @param {Number} length - Length of message (in bytes).\n     * @return {DiagnosticMessage}\n     */\n    setMessageLength (length) {\n        this.setParameter(DiagnosticMessage.KEY_MESSAGE_LENGTH, length);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMessageLength () {\n        return this.getParameter(DiagnosticMessage.KEY_MESSAGE_LENGTH);\n    }\n\n    /**\n     * @param {Number[]} data - Array of bytes comprising CAN message.\n     * @return {DiagnosticMessage}\n     */\n    setMessageData (data) {\n        this.setParameter(DiagnosticMessage.KEY_MESSAGE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getMessageData () {\n        return this.getParameter(DiagnosticMessage.KEY_MESSAGE_DATA);\n    }\n}\n\nDiagnosticMessage.KEY_TARGET_ID = 'targetID';\nDiagnosticMessage.KEY_MESSAGE_LENGTH = 'messageLength';\nDiagnosticMessage.KEY_MESSAGE_DATA = 'messageData';\n\nexport { DiagnosticMessage };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass DiagnosticMessageResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DiagnosticMessage);\n    }\n\n    /**\n     * @param {Number[]} result - Array of bytes comprising CAN message result.\n     * @return {DiagnosticMessageResponse}\n     */\n    setMessageDataResult (result) {\n        this.setParameter(DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT, result);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getMessageDataResult () {\n        return this.getParameter(DiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT);\n    }\n}\n\nDiagnosticMessageResponse.KEY_MESSAGE_DATA_RESULT = 'messageDataResult';\n\nexport { DiagnosticMessageResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { SoftButton } from '../structs/SoftButton.js';\n\n/**\n * Creates a full screen overlay containing a large block of formatted text that can be scrolled with up to 8\n * SoftButtons defined\n */\nclass ScrollableMessage extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ScrollableMessage);\n    }\n\n    /**\n     * @param {String} body - Body of text that can include newlines and tabs.\n     * @return {ScrollableMessage}\n     */\n    setScrollableMessageBody (body) {\n        this.setParameter(ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY, body);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getScrollableMessageBody () {\n        return this.getParameter(ScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY);\n    }\n\n    /**\n     * @param {Number} timeout - App defined timeout. Indicates how long of a timeout from the last action (i.e.\n     *                           scrolling message resets timeout).\n     * @return {ScrollableMessage}\n     */\n    setTimeout (timeout) {\n        this.setParameter(ScrollableMessage.KEY_TIMEOUT, timeout);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTimeout () {\n        return this.getParameter(ScrollableMessage.KEY_TIMEOUT);\n    }\n\n    /**\n     * @param {SoftButton[]} buttons - App defined SoftButtons. If omitted on supported displays, only the system\n     *                                 defined \"Close\" SoftButton will be displayed.\n     * @return {ScrollableMessage}\n     */\n    setSoftButtons (buttons) {\n        this.validateType(SoftButton, buttons, true);\n        this.setParameter(ScrollableMessage.KEY_SOFT_BUTTONS, buttons);\n        return this;\n    }\n\n    /**\n     * @return {SoftButton[]}\n     */\n    getSoftButtons () {\n        return this.getObject(SoftButton, ScrollableMessage.KEY_SOFT_BUTTONS);\n    }\n\n    /**\n     * @param {Number} id - An ID for this specific ScrollableMessage to allow cancellation through the\n     *                      `CancelInteraction` RPC.\n     * @return {ScrollableMessage}\n     */\n    setCancelID (id) {\n        this.setParameter(ScrollableMessage.KEY_CANCEL_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCancelID () {\n        return this.getParameter(ScrollableMessage.KEY_CANCEL_ID);\n    }\n}\n\nScrollableMessage.KEY_SCROLLABLE_MESSAGE_BODY = 'scrollableMessageBody';\nScrollableMessage.KEY_TIMEOUT = 'timeout';\nScrollableMessage.KEY_SOFT_BUTTONS = 'softButtons';\nScrollableMessage.KEY_CANCEL_ID = 'cancelID';\n\nexport { ScrollableMessage };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ScrollableMessageResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ScrollableMessage);\n    }\n}\n\n\nexport { ScrollableMessageResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Creates a full screen or pop-up overlay (depending on platform) with a single user controlled slider.\n */\nclass Slider extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Slider);\n    }\n\n    /**\n     * @param {Number} ticks - Number of selectable items on a horizontal axis\n     * @return {Slider}\n     */\n    setNumTicks (ticks) {\n        this.setParameter(Slider.KEY_NUM_TICKS, ticks);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getNumTicks () {\n        return this.getParameter(Slider.KEY_NUM_TICKS);\n    }\n\n    /**\n     * @param {Number} position - Initial position of slider control (cannot exceed numTicks)\n     * @return {Slider}\n     */\n    setPosition (position) {\n        this.setParameter(Slider.KEY_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPosition () {\n        return this.getParameter(Slider.KEY_POSITION);\n    }\n\n    /**\n     * @param {String} header - Text header to display\n     * @return {Slider}\n     */\n    setSliderHeader (header) {\n        this.setParameter(Slider.KEY_SLIDER_HEADER, header);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSliderHeader () {\n        return this.getParameter(Slider.KEY_SLIDER_HEADER);\n    }\n\n    /**\n     * @param {String[]} footer - Text footer to display (meant to display min/max threshold descriptors). For a static\n     *                            text footer, only one footer string shall be provided in the array. For a dynamic text\n     *                            footer, the number of footer text string in the array must match the numTicks value.\n     *                            For a dynamic text footer, text array string should correlate with potential slider\n     *                            position index. If omitted on supported displays, no footer text shall be displayed.\n     * @return {Slider}\n     */\n    setSliderFooter (footer) {\n        this.setParameter(Slider.KEY_SLIDER_FOOTER, footer);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getSliderFooter () {\n        return this.getParameter(Slider.KEY_SLIDER_FOOTER);\n    }\n\n    /**\n     * @param {Number} timeout - App defined timeout. Indicates how long of a timeout from the last action (i.e. sliding\n     *                           control resets timeout). If omitted, the value is set to 10000.\n     * @return {Slider}\n     */\n    setTimeout (timeout) {\n        this.setParameter(Slider.KEY_TIMEOUT, timeout);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTimeout () {\n        return this.getParameter(Slider.KEY_TIMEOUT);\n    }\n\n    /**\n     * @param {Number} id - An ID for this specific Slider to allow cancellation through the `CancelInteraction` RPC.\n     * @return {Slider}\n     */\n    setCancelID (id) {\n        this.setParameter(Slider.KEY_CANCEL_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCancelID () {\n        return this.getParameter(Slider.KEY_CANCEL_ID);\n    }\n}\n\nSlider.KEY_NUM_TICKS = 'numTicks';\nSlider.KEY_POSITION = 'position';\nSlider.KEY_SLIDER_HEADER = 'sliderHeader';\nSlider.KEY_SLIDER_FOOTER = 'sliderFooter';\nSlider.KEY_TIMEOUT = 'timeout';\nSlider.KEY_CANCEL_ID = 'cancelID';\n\nexport { Slider };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SliderResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.Slider);\n    }\n\n    /**\n     * @param {Number} position - Current slider value returned when saved or canceled (aborted) This value is only\n     *                            returned for resultCodes \"SAVED\" or \"ABORTED\"\n     * @return {SliderResponse}\n     */\n    setSliderPosition (position) {\n        this.setParameter(SliderResponse.KEY_SLIDER_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSliderPosition () {\n        return this.getParameter(SliderResponse.KEY_SLIDER_POSITION);\n    }\n}\n\nSliderResponse.KEY_SLIDER_POSITION = 'sliderPosition';\n\nexport { SliderResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { SoftButton } from '../structs/SoftButton.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { Image } from '../structs/Image.js';\n\nclass ShowConstantTBT extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ShowConstantTBT);\n    }\n\n    /**\n     * @param {String} text1\n     * @return {ShowConstantTBT}\n     */\n    setNavigationText1 (text1) {\n        this.setParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_1, text1);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getNavigationText1 () {\n        return this.getParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_1);\n    }\n\n    /**\n     * @param {String} text2\n     * @return {ShowConstantTBT}\n     */\n    setNavigationText2 (text2) {\n        this.setParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_2, text2);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getNavigationText2 () {\n        return this.getParameter(ShowConstantTBT.KEY_NAVIGATION_TEXT_2);\n    }\n\n    /**\n     * @param {String} eta\n     * @return {ShowConstantTBT}\n     */\n    setEta (eta) {\n        this.setParameter(ShowConstantTBT.KEY_ETA, eta);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getEta () {\n        return this.getParameter(ShowConstantTBT.KEY_ETA);\n    }\n\n    /**\n     * @param {String} destination\n     * @return {ShowConstantTBT}\n     */\n    setTimeToDestination (destination) {\n        this.setParameter(ShowConstantTBT.KEY_TIME_TO_DESTINATION, destination);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getTimeToDestination () {\n        return this.getParameter(ShowConstantTBT.KEY_TIME_TO_DESTINATION);\n    }\n\n    /**\n     * @param {String} distance\n     * @return {ShowConstantTBT}\n     */\n    setTotalDistance (distance) {\n        this.setParameter(ShowConstantTBT.KEY_TOTAL_DISTANCE, distance);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getTotalDistance () {\n        return this.getParameter(ShowConstantTBT.KEY_TOTAL_DISTANCE);\n    }\n\n    /**\n     * @param {Image} icon\n     * @return {ShowConstantTBT}\n     */\n    setTurnIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(ShowConstantTBT.KEY_TURN_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getTurnIcon () {\n        return this.getObject(Image, ShowConstantTBT.KEY_TURN_ICON);\n    }\n\n    /**\n     * @param {Image} icon\n     * @return {ShowConstantTBT}\n     */\n    setNextTurnIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(ShowConstantTBT.KEY_NEXT_TURN_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getNextTurnIcon () {\n        return this.getObject(Image, ShowConstantTBT.KEY_NEXT_TURN_ICON);\n    }\n\n    /**\n     * @param {Number} maneuver - Fraction of distance till next maneuver (starting from when AlertManeuver is\n     *                            triggered). Used to calculate progress bar.\n     * @return {ShowConstantTBT}\n     */\n    setDistanceToManeuver (maneuver) {\n        this.setParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER, maneuver);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDistanceToManeuver () {\n        return this.getParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER);\n    }\n\n    /**\n     * @param {Number} scale - Distance till next maneuver (starting from) from previous maneuver. Used to calculate\n     *                         progress bar.\n     * @return {ShowConstantTBT}\n     */\n    setDistanceToManeuverScale (scale) {\n        this.setParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE, scale);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDistanceToManeuverScale () {\n        return this.getParameter(ShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE);\n    }\n\n    /**\n     * @param {Boolean} complete - If and when a maneuver has completed while an AlertManeuver is active, the app must\n     *                             send this value set to TRUE in order to clear the AlertManeuver overlay. If omitted\n     *                             the value will be assumed as FALSE.\n     * @return {ShowConstantTBT}\n     */\n    setManeuverComplete (complete) {\n        this.setParameter(ShowConstantTBT.KEY_MANEUVER_COMPLETE, complete);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getManeuverComplete () {\n        return this.getParameter(ShowConstantTBT.KEY_MANEUVER_COMPLETE);\n    }\n\n    /**\n     * @param {SoftButton[]} buttons - Three dynamic SoftButtons available (first SoftButton is fixed to \"Turns\"). If\n     *                                 omitted on supported displays, the currently displayed SoftButton values will not\n     *                                 change.\n     * @return {ShowConstantTBT}\n     */\n    setSoftButtons (buttons) {\n        this.validateType(SoftButton, buttons, true);\n        this.setParameter(ShowConstantTBT.KEY_SOFT_BUTTONS, buttons);\n        return this;\n    }\n\n    /**\n     * @return {SoftButton[]}\n     */\n    getSoftButtons () {\n        return this.getObject(SoftButton, ShowConstantTBT.KEY_SOFT_BUTTONS);\n    }\n}\n\nShowConstantTBT.KEY_NAVIGATION_TEXT_1 = 'navigationText1';\nShowConstantTBT.KEY_NAVIGATION_TEXT_2 = 'navigationText2';\nShowConstantTBT.KEY_ETA = 'eta';\nShowConstantTBT.KEY_TIME_TO_DESTINATION = 'timeToDestination';\nShowConstantTBT.KEY_TOTAL_DISTANCE = 'totalDistance';\nShowConstantTBT.KEY_TURN_ICON = 'turnIcon';\nShowConstantTBT.KEY_NEXT_TURN_ICON = 'nextTurnIcon';\nShowConstantTBT.KEY_DISTANCE_TO_MANEUVER = 'distanceToManeuver';\nShowConstantTBT.KEY_DISTANCE_TO_MANEUVER_SCALE = 'distanceToManeuverScale';\nShowConstantTBT.KEY_MANEUVER_COMPLETE = 'maneuverComplete';\nShowConstantTBT.KEY_SOFT_BUTTONS = 'softButtons';\n\nexport { ShowConstantTBT };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ShowConstantTBTResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ShowConstantTBT);\n    }\n}\n\n\nexport { ShowConstantTBTResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { SoftButton } from '../structs/SoftButton.js';\n\nclass AlertManeuver extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AlertManeuver);\n    }\n\n    /**\n     * @param {TTSChunk[]} chunks - An array of text chunks of type TTSChunk. See TTSChunk\n     * @return {AlertManeuver}\n     */\n    setTtsChunks (chunks) {\n        this.validateType(TTSChunk, chunks, true);\n        this.setParameter(AlertManeuver.KEY_TTS_CHUNKS, chunks);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getTtsChunks () {\n        return this.getObject(TTSChunk, AlertManeuver.KEY_TTS_CHUNKS);\n    }\n\n    /**\n     * @param {SoftButton[]} buttons - If omitted on supported displays, only the system defined \"Close\" SoftButton\n     *                                 shall be displayed.\n     * @return {AlertManeuver}\n     */\n    setSoftButtons (buttons) {\n        this.validateType(SoftButton, buttons, true);\n        this.setParameter(AlertManeuver.KEY_SOFT_BUTTONS, buttons);\n        return this;\n    }\n\n    /**\n     * @return {SoftButton[]}\n     */\n    getSoftButtons () {\n        return this.getObject(SoftButton, AlertManeuver.KEY_SOFT_BUTTONS);\n    }\n}\n\nAlertManeuver.KEY_TTS_CHUNKS = 'ttsChunks';\nAlertManeuver.KEY_SOFT_BUTTONS = 'softButtons';\n\nexport { AlertManeuver };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass AlertManeuverResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.AlertManeuver);\n    }\n}\n\n\nexport { AlertManeuverResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { Image } from './Image.js';\n\nclass Turn extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} text - Individual turn text. Must provide at least text or icon for a given turn.\n     * @return {Turn}\n     */\n    setNavigationText (text) {\n        this.setParameter(Turn.KEY_NAVIGATION_TEXT, text);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getNavigationText () {\n        return this.getParameter(Turn.KEY_NAVIGATION_TEXT);\n    }\n\n    /**\n     * @param {Image} icon - Individual turn icon. Must provide at least text or icon for a given turn.\n     * @return {Turn}\n     */\n    setTurnIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(Turn.KEY_TURN_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getTurnIcon () {\n        return this.getObject(Image, Turn.KEY_TURN_ICON);\n    }\n}\n\nTurn.KEY_NAVIGATION_TEXT = 'navigationText';\nTurn.KEY_TURN_ICON = 'turnIcon';\n\nexport { Turn };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Turn } from '../structs/Turn.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { SoftButton } from '../structs/SoftButton.js';\n\nclass UpdateTurnList extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UpdateTurnList);\n    }\n\n    /**\n     * @param {Turn[]} list\n     * @return {UpdateTurnList}\n     */\n    setTurnList (list) {\n        this.validateType(Turn, list, true);\n        this.setParameter(UpdateTurnList.KEY_TURN_LIST, list);\n        return this;\n    }\n\n    /**\n     * @return {Turn[]}\n     */\n    getTurnList () {\n        return this.getObject(Turn, UpdateTurnList.KEY_TURN_LIST);\n    }\n\n    /**\n     * @param {SoftButton[]} buttons - If omitted on supported displays, app-defined SoftButton will be left blank.\n     * @return {UpdateTurnList}\n     */\n    setSoftButtons (buttons) {\n        this.validateType(SoftButton, buttons, true);\n        this.setParameter(UpdateTurnList.KEY_SOFT_BUTTONS, buttons);\n        return this;\n    }\n\n    /**\n     * @return {SoftButton[]}\n     */\n    getSoftButtons () {\n        return this.getObject(SoftButton, UpdateTurnList.KEY_SOFT_BUTTONS);\n    }\n}\n\nUpdateTurnList.KEY_TURN_LIST = 'turnList';\nUpdateTurnList.KEY_SOFT_BUTTONS = 'softButtons';\n\nexport { UpdateTurnList };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass UpdateTurnListResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UpdateTurnList);\n    }\n}\n\n\nexport { UpdateTurnListResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { TTSChunk } from '../structs/TTSChunk.js';\nimport { Language } from '../enums/Language.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass ChangeRegistration extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ChangeRegistration);\n    }\n\n    /**\n     * @param {Language} language - Requested voice engine (VR+TTS) language registration\n     * @return {ChangeRegistration}\n     */\n    setLanguage (language) {\n        this.validateType(Language, language);\n        this.setParameter(ChangeRegistration.KEY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getLanguage () {\n        return this.getObject(Language, ChangeRegistration.KEY_LANGUAGE);\n    }\n\n    /**\n     * @param {Language} language - Request display language registration\n     * @return {ChangeRegistration}\n     */\n    setHmiDisplayLanguage (language) {\n        this.validateType(Language, language);\n        this.setParameter(ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getHmiDisplayLanguage () {\n        return this.getObject(Language, ChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE);\n    }\n\n    /**\n     * @param {String} name - Request new app name registration\n     * @return {ChangeRegistration}\n     */\n    setAppName (name) {\n        this.setParameter(ChangeRegistration.KEY_APP_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppName () {\n        return this.getParameter(ChangeRegistration.KEY_APP_NAME);\n    }\n\n    /**\n     * @param {TTSChunk[]} name - Request new ttsName registration\n     * @return {ChangeRegistration}\n     */\n    setTtsName (name) {\n        this.validateType(TTSChunk, name, true);\n        this.setParameter(ChangeRegistration.KEY_TTS_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {TTSChunk[]}\n     */\n    getTtsName () {\n        return this.getObject(TTSChunk, ChangeRegistration.KEY_TTS_NAME);\n    }\n\n    /**\n     * @param {String} name - Request new app short name registration\n     * @return {ChangeRegistration}\n     */\n    setNgnMediaScreenAppName (name) {\n        this.setParameter(ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getNgnMediaScreenAppName () {\n        return this.getParameter(ChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME);\n    }\n\n    /**\n     * @param {String[]} synonyms - Request new VR synonyms registration\n     * @return {ChangeRegistration}\n     */\n    setVrSynonyms (synonyms) {\n        this.setParameter(ChangeRegistration.KEY_VR_SYNONYMS, synonyms);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getVrSynonyms () {\n        return this.getParameter(ChangeRegistration.KEY_VR_SYNONYMS);\n    }\n}\n\nChangeRegistration.KEY_LANGUAGE = 'language';\nChangeRegistration.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage';\nChangeRegistration.KEY_APP_NAME = 'appName';\nChangeRegistration.KEY_TTS_NAME = 'ttsName';\nChangeRegistration.KEY_NGN_MEDIA_SCREEN_APP_NAME = 'ngnMediaScreenAppName';\nChangeRegistration.KEY_VR_SYNONYMS = 'vrSynonyms';\n\nexport { ChangeRegistration };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ChangeRegistrationResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ChangeRegistration);\n    }\n}\n\n\nexport { ChangeRegistrationResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * Generic Response is sent, when the name of a received msg cannot be retrieved. Only used in case of an error.\n * Currently, only resultCode INVALID_DATA is used.\n */\nclass GenericResponseResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GenericResponse);\n    }\n}\n\n\nexport { GenericResponseResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FileType } from '../enums/FileType.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Used to push a binary data onto the module from a mobile device, such as icons and album art Not supported on first\n * generation of SDL enabled modules. Binary data is in binary part of hybrid msg.\n */\nclass PutFile extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PutFile);\n    }\n\n    // ------ Not part of the RPC spec itself -----\n\n    /**\n     * @param {Uint8Array} fileData\n     * @return {PutFile}\n     */\n    setFileData (fileData) {\n        this.setBulkData(fileData);\n        return this;\n    }\n    /**\n     * @return {Uint8Array}\n     */\n    getFileData () {\n        return this.getBulkData();\n    }\n\n    // ----------------- END -----------------------\n\n    /**\n     * @param {String} name - File reference name.\n     * @return {PutFile}\n     */\n    setFileName (name) {\n        this.setParameter(PutFile.KEY_FILE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getFileName () {\n        return this.getParameter(PutFile.KEY_FILE_NAME);\n    }\n\n    /**\n     * @param {FileType} type - Selected file type.\n     * @return {PutFile}\n     */\n    setFileType (type) {\n        this.validateType(FileType, type);\n        this.setParameter(PutFile.KEY_FILE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {FileType}\n     */\n    getFileType () {\n        return this.getObject(FileType, PutFile.KEY_FILE_TYPE);\n    }\n\n    /**\n     * @param {Boolean} file - Indicates if the file is meant to persist between sessions / ignition cycles. If set to\n     *                         TRUE, then the system will aim to persist this file through session / cycles. While files\n     *                         with this designation will have priority over others, they are subject to deletion by the\n     *                         system at any time. In the event of automatic deletion by the system, the app will\n     *                         receive a rejection and have to resend the file. If omitted, the value will be set to\n     *                         false.\n     * @return {PutFile}\n     */\n    setPersistentFile (file) {\n        this.setParameter(PutFile.KEY_PERSISTENT_FILE, file);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getPersistentFile () {\n        return this.getParameter(PutFile.KEY_PERSISTENT_FILE);\n    }\n\n    /**\n     * @param {Boolean} file - Indicates if the file is meant to be passed thru core to elsewhere on the system. If set\n     *                         to TRUE, then the system will instead pass the data thru as it arrives to a predetermined\n     *                         area outside of core. If omitted, the value will be set to false.\n     * @return {PutFile}\n     */\n    setSystemFile (file) {\n        this.setParameter(PutFile.KEY_SYSTEM_FILE, file);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSystemFile () {\n        return this.getParameter(PutFile.KEY_SYSTEM_FILE);\n    }\n\n    /**\n     * @param {Number} offset - Optional offset in bytes for resuming partial data chunks\n     * @return {PutFile}\n     */\n    setOffset (offset) {\n        this.setParameter(PutFile.KEY_OFFSET, offset);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getOffset () {\n        return this.getParameter(PutFile.KEY_OFFSET);\n    }\n\n    /**\n     * @param {Number} length - Optional length in bytes for resuming partial data chunks If offset is set to 0, then\n     *                          length is the total length of the file to be downloaded\n     * @return {PutFile}\n     */\n    setLength (length) {\n        this.setParameter(PutFile.KEY_LENGTH, length);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLength () {\n        return this.getParameter(PutFile.KEY_LENGTH);\n    }\n\n    /**\n     * @param {Number} crc - Additional CRC32 checksum to protect data integrity up to 512 Mbits\n     * @return {PutFile}\n     */\n    setCrc (crc) {\n        this.setParameter(PutFile.KEY_CRC, crc);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCrc () {\n        return this.getParameter(PutFile.KEY_CRC);\n    }\n}\n\nPutFile.KEY_FILE_NAME = 'syncFileName';\nPutFile.KEY_FILE_TYPE = 'fileType';\nPutFile.KEY_PERSISTENT_FILE = 'persistentFile';\nPutFile.KEY_SYSTEM_FILE = 'systemFile';\nPutFile.KEY_OFFSET = 'offset';\nPutFile.KEY_LENGTH = 'length';\nPutFile.KEY_CRC = 'crc';\n\nexport { PutFile };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * Response is sent, when the file data was copied (success case). Or when an error occurred. Not supported on first\n * generation SDL enabled vehicles.\n */\nclass PutFileResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PutFile);\n    }\n\n    /**\n     * @param {Number} available - Provides the total local space available in SDL Core for the registered app. If the\n     *                             transfer has systemFile enabled, then the value will be set to 0 automatically.\n     * @return {PutFileResponse}\n     */\n    setSpaceAvailable (available) {\n        this.setParameter(PutFileResponse.KEY_SPACE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSpaceAvailable () {\n        return this.getParameter(PutFileResponse.KEY_SPACE_AVAILABLE);\n    }\n}\n\nPutFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable';\n\nexport { PutFileResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FileType } from '../enums/FileType.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * This request is sent to the module to retrieve a file\n */\nclass GetFile extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetFile);\n    }\n\n    /**\n     * @param {String} name - File name that should be retrieved\n     * @return {GetFile}\n     */\n    setFileName (name) {\n        this.setParameter(GetFile.KEY_FILE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getFileName () {\n        return this.getParameter(GetFile.KEY_FILE_NAME);\n    }\n\n    /**\n     * @param {String} id - ID of the service that should have uploaded the requested file.\n     * @return {GetFile}\n     */\n    setAppServiceId (id) {\n        this.setParameter(GetFile.KEY_APP_SERVICE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppServiceId () {\n        return this.getParameter(GetFile.KEY_APP_SERVICE_ID);\n    }\n\n    /**\n     * @param {FileType} type - Selected file type.\n     * @return {GetFile}\n     */\n    setFileType (type) {\n        this.validateType(FileType, type);\n        this.setParameter(GetFile.KEY_FILE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {FileType}\n     */\n    getFileType () {\n        return this.getObject(FileType, GetFile.KEY_FILE_TYPE);\n    }\n\n    /**\n     * @param {Number} offset - Optional offset in bytes for resuming partial data chunks\n     * @return {GetFile}\n     */\n    setOffset (offset) {\n        this.setParameter(GetFile.KEY_OFFSET, offset);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getOffset () {\n        return this.getParameter(GetFile.KEY_OFFSET);\n    }\n\n    /**\n     * @param {Number} length - Optional length in bytes for resuming partial data chunks If offset is set to 0, then\n     *                          length is the total length of the file to be retrieved\n     * @return {GetFile}\n     */\n    setLength (length) {\n        this.setParameter(GetFile.KEY_LENGTH, length);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLength () {\n        return this.getParameter(GetFile.KEY_LENGTH);\n    }\n}\n\nGetFile.KEY_FILE_NAME = 'fileName';\nGetFile.KEY_APP_SERVICE_ID = 'appServiceId';\nGetFile.KEY_FILE_TYPE = 'fileType';\nGetFile.KEY_OFFSET = 'offset';\nGetFile.KEY_LENGTH = 'length';\n\nexport { GetFile };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\nimport { FileType } from '../enums/FileType.js';\n\n/**\n * This response includes the data that is requested from the specific service\n */\nclass GetFileResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetFile);\n    }\n\n    /**\n     * @param {Number} offset - Optional offset in bytes for resuming partial data chunks\n     * @return {GetFileResponse}\n     */\n    setOffset (offset) {\n        this.setParameter(GetFileResponse.KEY_OFFSET, offset);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getOffset () {\n        return this.getParameter(GetFileResponse.KEY_OFFSET);\n    }\n\n    /**\n     * @param {Number} length - Optional length in bytes for resuming partial data chunks if offset is set to 0, then\n     *                          length is the total length of the file to be downloaded\n     * @return {GetFileResponse}\n     */\n    setLength (length) {\n        this.setParameter(GetFileResponse.KEY_LENGTH, length);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLength () {\n        return this.getParameter(GetFileResponse.KEY_LENGTH);\n    }\n\n    /**\n     * @param {FileType} type - File type that is being sent in response.\n     * @return {GetFileResponse}\n     */\n    setFileType (type) {\n        this.validateType(FileType, type);\n        this.setParameter(GetFileResponse.KEY_FILE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {FileType}\n     */\n    getFileType () {\n        return this.getObject(FileType, GetFileResponse.KEY_FILE_TYPE);\n    }\n\n    /**\n     * @param {Number} crc - Additional CRC32 checksum to protect data integrity up to 512 Mbits\n     * @return {GetFileResponse}\n     */\n    setCrc (crc) {\n        this.setParameter(GetFileResponse.KEY_CRC, crc);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCrc () {\n        return this.getParameter(GetFileResponse.KEY_CRC);\n    }\n}\n\nGetFileResponse.KEY_OFFSET = 'offset';\nGetFileResponse.KEY_LENGTH = 'length';\nGetFileResponse.KEY_FILE_TYPE = 'fileType';\nGetFileResponse.KEY_CRC = 'crc';\n\nexport { GetFileResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Used to delete a file resident on the module in the app's local cache. Not supported on first generation SDL enabled\n * vehicles.\n */\nclass DeleteFile extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteFile);\n    }\n\n    /**\n     * @param {String} name - File reference name.\n     * @return {DeleteFile}\n     */\n    setSdlFileName (name) {\n        this.setParameter(DeleteFile.KEY_SDL_FILE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSdlFileName () {\n        return this.getParameter(DeleteFile.KEY_SDL_FILE_NAME);\n    }\n}\n\nDeleteFile.KEY_SDL_FILE_NAME = 'syncFileName';\n\nexport { DeleteFile };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * Response is sent, when the file data was deleted (success case). Or when an error occurred. Not supported on First\n * generation SDL enabled vehicles.\n */\nclass DeleteFileResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DeleteFile);\n    }\n\n    /**\n     * @param {Number} available - Provides the total local space available on the module for the registered app.\n     * @return {DeleteFileResponse}\n     */\n    setSpaceAvailable (available) {\n        this.setParameter(DeleteFileResponse.KEY_SPACE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSpaceAvailable () {\n        return this.getParameter(DeleteFileResponse.KEY_SPACE_AVAILABLE);\n    }\n}\n\nDeleteFileResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable';\n\nexport { DeleteFileResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Requests the current list of resident filenames for the registered app. Not supported on first generation SDL\n * enabled vehicles.\n */\nclass ListFiles extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ListFiles);\n    }\n}\n\n\nexport { ListFiles };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * Returns the current list of resident filenames for the registered app along with the current space available Not\n * supported on First generation SDL enabled vehicles.\n */\nclass ListFilesResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ListFiles);\n    }\n\n    /**\n     * @param {String[]} filenames - An array of all filenames resident on the module for the given registered app. If\n     *                               omitted, then no files currently reside on the system.\n     * @return {ListFilesResponse}\n     */\n    setFilenames (filenames) {\n        this.setParameter(ListFilesResponse.KEY_FILENAMES, filenames);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getFilenames () {\n        return this.getParameter(ListFilesResponse.KEY_FILENAMES);\n    }\n\n    /**\n     * @param {Number} available - Provides the total local space available on the module for the registered app.\n     * @return {ListFilesResponse}\n     */\n    setSpaceAvailable (available) {\n        this.setParameter(ListFilesResponse.KEY_SPACE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSpaceAvailable () {\n        return this.getParameter(ListFilesResponse.KEY_SPACE_AVAILABLE);\n    }\n}\n\nListFilesResponse.KEY_FILENAMES = 'filenames';\nListFilesResponse.KEY_SPACE_AVAILABLE = 'spaceAvailable';\n\nexport { ListFilesResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Used to set existing local file on the module as the app's icon Not supported on first generation SDL enabled\n * vehicles.\n */\nclass SetAppIcon extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetAppIcon);\n    }\n\n    /**\n     * @param {String} name - File reference name.\n     * @return {SetAppIcon}\n     */\n    setFileName (name) {\n        this.setParameter(SetAppIcon.KEY_FILE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getFileName () {\n        return this.getParameter(SetAppIcon.KEY_FILE_NAME);\n    }\n}\n\nSetAppIcon.KEY_FILE_NAME = 'syncFileName';\n\nexport { SetAppIcon };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * Response is sent, when the file data was copied (success case). Or when an error occurred. Not supported on First\n * generation SDL enabled vehicles.\n */\nclass SetAppIconResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetAppIcon);\n    }\n}\n\n\nexport { SetAppIconResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { TemplateColorScheme } from '../structs/TemplateColorScheme.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * This RPC is deprecated. Use Show RPC to change layout.\n * @deprecated\n */\nclass SetDisplayLayout extends RpcRequest {\n    /**\n     * @deprecated\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetDisplayLayout);\n    }\n\n    /**\n     * @deprecated\n     * @param {String} layout - Predefined or dynamically created screen layout. Currently only predefined screen\n     *                          layouts are defined.\n     * @return {SetDisplayLayout}\n     */\n    setDisplayLayout (layout) {\n        this.setParameter(SetDisplayLayout.KEY_DISPLAY_LAYOUT, layout);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    getDisplayLayout () {\n        return this.getParameter(SetDisplayLayout.KEY_DISPLAY_LAYOUT);\n    }\n\n    /**\n     * @deprecated\n     * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates.\n     * @return {SetDisplayLayout}\n     */\n    setDayColorScheme (scheme) {\n        this.validateType(TemplateColorScheme, scheme);\n        this.setParameter(SetDisplayLayout.KEY_DAY_COLOR_SCHEME, scheme);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {TemplateColorScheme}\n     */\n    getDayColorScheme () {\n        return this.getObject(TemplateColorScheme, SetDisplayLayout.KEY_DAY_COLOR_SCHEME);\n    }\n\n    /**\n     * @deprecated\n     * @param {TemplateColorScheme} scheme - A color scheme for all display layout templates.\n     * @return {SetDisplayLayout}\n     */\n    setNightColorScheme (scheme) {\n        this.validateType(TemplateColorScheme, scheme);\n        this.setParameter(SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME, scheme);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {TemplateColorScheme}\n     */\n    getNightColorScheme () {\n        return this.getObject(TemplateColorScheme, SetDisplayLayout.KEY_NIGHT_COLOR_SCHEME);\n    }\n}\n\nSetDisplayLayout.KEY_DISPLAY_LAYOUT = 'displayLayout';\nSetDisplayLayout.KEY_DAY_COLOR_SCHEME = 'dayColorScheme';\nSetDisplayLayout.KEY_NIGHT_COLOR_SCHEME = 'nightColorScheme';\n\nexport { SetDisplayLayout };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcResponse } from '../RpcResponse.js';\nimport { SoftButtonCapabilities } from '../structs/SoftButtonCapabilities.js';\nimport { PresetBankCapabilities } from '../structs/PresetBankCapabilities.js';\nimport { DisplayCapabilities } from '../structs/DisplayCapabilities.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ButtonCapabilities } from '../structs/ButtonCapabilities.js';\n\n/**\n * This RPC is deprecated. Use Show RPC to change layout.\n * @deprecated\n */\nclass SetDisplayLayoutResponse extends RpcResponse {\n    /**\n     * @deprecated\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetDisplayLayout);\n    }\n\n    /**\n     * @deprecated\n     * @param {DisplayCapabilities} capabilities - See DisplayCapabilities\n     * @return {SetDisplayLayoutResponse}\n     */\n    setDisplayCapabilities (capabilities) {\n        this.validateType(DisplayCapabilities, capabilities);\n        this.setParameter(SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {DisplayCapabilities}\n     */\n    getDisplayCapabilities () {\n        return this.getObject(DisplayCapabilities, SetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES);\n    }\n\n    /**\n     * @deprecated\n     * @param {ButtonCapabilities[]} capabilities - See ButtonCapabilities\n     * @return {SetDisplayLayoutResponse}\n     */\n    setButtonCapabilities (capabilities) {\n        this.validateType(ButtonCapabilities, capabilities, true);\n        this.setParameter(SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {ButtonCapabilities[]}\n     */\n    getButtonCapabilities () {\n        return this.getObject(ButtonCapabilities, SetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES);\n    }\n\n    /**\n     * @deprecated\n     * @param {SoftButtonCapabilities[]} capabilities - If returned, the platform supports on-screen SoftButtons; see\n     *                                                  SoftButtonCapabilities.\n     * @return {SetDisplayLayoutResponse}\n     */\n    setSoftButtonCapabilities (capabilities) {\n        this.validateType(SoftButtonCapabilities, capabilities, true);\n        this.setParameter(SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {SoftButtonCapabilities[]}\n     */\n    getSoftButtonCapabilities () {\n        return this.getObject(SoftButtonCapabilities, SetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES);\n    }\n\n    /**\n     * @deprecated\n     * @param {PresetBankCapabilities} capabilities - If returned, the platform supports custom on-screen Presets; see\n     *                                                PresetBankCapabilities.\n     * @return {SetDisplayLayoutResponse}\n     */\n    setPresetBankCapabilities (capabilities) {\n        this.validateType(PresetBankCapabilities, capabilities);\n        this.setParameter(SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @deprecated\n     * @return {PresetBankCapabilities}\n     */\n    getPresetBankCapabilities () {\n        return this.getObject(PresetBankCapabilities, SetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES);\n    }\n}\n\nSetDisplayLayoutResponse.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities';\nSetDisplayLayoutResponse.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities';\nSetDisplayLayoutResponse.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities';\nSetDisplayLayoutResponse.KEY_PRESET_BANK_CAPABILITIES = 'presetBankCapabilities';\n\nexport { SetDisplayLayoutResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration listing possible asynchronous requests.\n * @typedef {Enum} RequestType\n * @property {Object} _MAP\n */\nclass RequestType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HTTP () {\n        return RequestType._MAP.HTTP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FILE_RESUME () {\n        return RequestType._MAP.FILE_RESUME;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTH_REQUEST () {\n        return RequestType._MAP.AUTH_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTH_CHALLENGE () {\n        return RequestType._MAP.AUTH_CHALLENGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTH_ACK () {\n        return RequestType._MAP.AUTH_ACK;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PROPRIETARY () {\n        return RequestType._MAP.PROPRIETARY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get QUERY_APPS () {\n        return RequestType._MAP.QUERY_APPS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LAUNCH_APP () {\n        return RequestType._MAP.LAUNCH_APP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LOCK_SCREEN_ICON_URL () {\n        return RequestType._MAP.LOCK_SCREEN_ICON_URL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TRAFFIC_MESSAGE_CHANNEL () {\n        return RequestType._MAP.TRAFFIC_MESSAGE_CHANNEL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DRIVER_PROFILE () {\n        return RequestType._MAP.DRIVER_PROFILE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VOICE_SEARCH () {\n        return RequestType._MAP.VOICE_SEARCH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAVIGATION () {\n        return RequestType._MAP.NAVIGATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PHONE () {\n        return RequestType._MAP.PHONE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLIMATE () {\n        return RequestType._MAP.CLIMATE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SETTINGS () {\n        return RequestType._MAP.SETTINGS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VEHICLE_DIAGNOSTICS () {\n        return RequestType._MAP.VEHICLE_DIAGNOSTICS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EMERGENCY () {\n        return RequestType._MAP.EMERGENCY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MEDIA () {\n        return RequestType._MAP.MEDIA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FOTA () {\n        return RequestType._MAP.FOTA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OEM_SPECIFIC () {\n        return RequestType._MAP.OEM_SPECIFIC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ICON_URL () {\n        return RequestType._MAP.ICON_URL;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return RequestType._valueForKey(key, RequestType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return RequestType._keyForValue(value, RequestType._MAP);\n    }\n}\n\nRequestType._MAP = Object.freeze({\n    'HTTP': 'HTTP',\n    'FILE_RESUME': 'FILE_RESUME',\n    'AUTH_REQUEST': 'AUTH_REQUEST',\n    'AUTH_CHALLENGE': 'AUTH_CHALLENGE',\n    'AUTH_ACK': 'AUTH_ACK',\n    'PROPRIETARY': 'PROPRIETARY',\n    'QUERY_APPS': 'QUERY_APPS',\n    'LAUNCH_APP': 'LAUNCH_APP',\n    'LOCK_SCREEN_ICON_URL': 'LOCK_SCREEN_ICON_URL',\n    'TRAFFIC_MESSAGE_CHANNEL': 'TRAFFIC_MESSAGE_CHANNEL',\n    'DRIVER_PROFILE': 'DRIVER_PROFILE',\n    'VOICE_SEARCH': 'VOICE_SEARCH',\n    'NAVIGATION': 'NAVIGATION',\n    'PHONE': 'PHONE',\n    'CLIMATE': 'CLIMATE',\n    'SETTINGS': 'SETTINGS',\n    'VEHICLE_DIAGNOSTICS': 'VEHICLE_DIAGNOSTICS',\n    'EMERGENCY': 'EMERGENCY',\n    'MEDIA': 'MEDIA',\n    'FOTA': 'FOTA',\n    'OEM_SPECIFIC': 'OEM_SPECIFIC',\n    'ICON_URL': 'ICON_URL',\n});\n\nexport { RequestType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { RequestType } from '../enums/RequestType.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * An asynchronous request from the device; binary data can be included in hybrid part of message for some requests\n * (such as HTTP, Proprietary, or Authentication requests)\n */\nclass SystemRequest extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SystemRequest);\n    }\n\n    /**\n     * @param {RequestType} type - The type of system request. Note that Proprietary requests should forward the binary\n     *                             data to the known proprietary module on the system.\n     * @return {SystemRequest}\n     */\n    setRequestType (type) {\n        this.validateType(RequestType, type);\n        this.setParameter(SystemRequest.KEY_REQUEST_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {RequestType}\n     */\n    getRequestType () {\n        return this.getObject(RequestType, SystemRequest.KEY_REQUEST_TYPE);\n    }\n\n    /**\n     * @param {String} type - This parameter is filled for supporting OEM proprietary data exchanges.\n     * @return {SystemRequest}\n     */\n    setRequestSubType (type) {\n        this.setParameter(SystemRequest.KEY_REQUEST_SUB_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getRequestSubType () {\n        return this.getParameter(SystemRequest.KEY_REQUEST_SUB_TYPE);\n    }\n\n    /**\n     * @param {String} name - Filename of HTTP data to store in predefined system staging area. Mandatory if requestType\n     *                        is HTTP. PROPRIETARY requestType should ignore this parameter.\n     * @return {SystemRequest}\n     */\n    setFileName (name) {\n        this.setParameter(SystemRequest.KEY_FILE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getFileName () {\n        return this.getParameter(SystemRequest.KEY_FILE_NAME);\n    }\n}\n\nSystemRequest.KEY_REQUEST_TYPE = 'requestType';\nSystemRequest.KEY_REQUEST_SUB_TYPE = 'requestSubType';\nSystemRequest.KEY_FILE_NAME = 'fileName';\n\nexport { SystemRequest };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SystemRequestResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SystemRequest);\n    }\n}\n\n\nexport { SystemRequestResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * The mode in which the SendLocation request is sent\n * @typedef {Enum} DeliveryMode\n * @property {Object} _MAP\n */\nclass DeliveryMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PROMPT () {\n        return DeliveryMode._MAP.PROMPT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DESTINATION () {\n        return DeliveryMode._MAP.DESTINATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get QUEUE () {\n        return DeliveryMode._MAP.QUEUE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return DeliveryMode._valueForKey(key, DeliveryMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return DeliveryMode._keyForValue(value, DeliveryMode._MAP);\n    }\n}\n\nDeliveryMode._MAP = Object.freeze({\n    'PROMPT': 'PROMPT',\n    'DESTINATION': 'DESTINATION',\n    'QUEUE': 'QUEUE',\n});\n\nexport { DeliveryMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass DateTime extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} millisecond - Milliseconds\n     * @return {DateTime}\n     */\n    setMillisecond (millisecond) {\n        this.setParameter(DateTime.KEY_MILLISECOND, millisecond);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMillisecond () {\n        return this.getParameter(DateTime.KEY_MILLISECOND);\n    }\n\n    /**\n     * @param {Number} second - Seconds part of time\n     * @return {DateTime}\n     */\n    setSecond (second) {\n        this.setParameter(DateTime.KEY_SECOND, second);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSecond () {\n        return this.getParameter(DateTime.KEY_SECOND);\n    }\n\n    /**\n     * @param {Number} minute - Minutes part of time\n     * @return {DateTime}\n     */\n    setMinute (minute) {\n        this.setParameter(DateTime.KEY_MINUTE, minute);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMinute () {\n        return this.getParameter(DateTime.KEY_MINUTE);\n    }\n\n    /**\n     * @param {Number} hour - Hours part of time. Note that this structure accepts time only in 24 Hr format\n     * @return {DateTime}\n     */\n    setHour (hour) {\n        this.setParameter(DateTime.KEY_HOUR, hour);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHour () {\n        return this.getParameter(DateTime.KEY_HOUR);\n    }\n\n    /**\n     * @param {Number} day - Day of the month\n     * @return {DateTime}\n     */\n    setDay (day) {\n        this.setParameter(DateTime.KEY_DAY, day);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDay () {\n        return this.getParameter(DateTime.KEY_DAY);\n    }\n\n    /**\n     * @param {Number} month - Month of the year\n     * @return {DateTime}\n     */\n    setMonth (month) {\n        this.setParameter(DateTime.KEY_MONTH, month);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMonth () {\n        return this.getParameter(DateTime.KEY_MONTH);\n    }\n\n    /**\n     * @param {Number} year - The year in YYYY format\n     * @return {DateTime}\n     */\n    setYear (year) {\n        this.setParameter(DateTime.KEY_YEAR, year);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getYear () {\n        return this.getParameter(DateTime.KEY_YEAR);\n    }\n\n    /**\n     * @param {Number} tz_hour - Time zone offset in Hours wrt UTC.\n     * @return {DateTime}\n     */\n    setTz_hour (tz_hour) {\n        this.setParameter(DateTime.KEY_TZ_HOUR, tz_hour);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTz_hour () {\n        return this.getParameter(DateTime.KEY_TZ_HOUR);\n    }\n\n    /**\n     * @param {Number} tz_minute - Time zone offset in Min wrt UTC.\n     * @return {DateTime}\n     */\n    setTz_minute (tz_minute) {\n        this.setParameter(DateTime.KEY_TZ_MINUTE, tz_minute);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTz_minute () {\n        return this.getParameter(DateTime.KEY_TZ_MINUTE);\n    }\n}\n\nDateTime.KEY_MILLISECOND = 'millisecond';\nDateTime.KEY_SECOND = 'second';\nDateTime.KEY_MINUTE = 'minute';\nDateTime.KEY_HOUR = 'hour';\nDateTime.KEY_DAY = 'day';\nDateTime.KEY_MONTH = 'month';\nDateTime.KEY_YEAR = 'year';\nDateTime.KEY_TZ_HOUR = 'tz_hour';\nDateTime.KEY_TZ_MINUTE = 'tz_minute';\n\nexport { DateTime };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass OASISAddress extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - Name of the country (localized)\n     * @return {OASISAddress}\n     */\n    setCountryName (name) {\n        this.setParameter(OASISAddress.KEY_COUNTRY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getCountryName () {\n        return this.getParameter(OASISAddress.KEY_COUNTRY_NAME);\n    }\n\n    /**\n     * @param {String} code - Name of country (ISO 3166-2)\n     * @return {OASISAddress}\n     */\n    setCountryCode (code) {\n        this.setParameter(OASISAddress.KEY_COUNTRY_CODE, code);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getCountryCode () {\n        return this.getParameter(OASISAddress.KEY_COUNTRY_CODE);\n    }\n\n    /**\n     * @param {String} code - (PLZ, ZIP, PIN, CAP etc.)\n     * @return {OASISAddress}\n     */\n    setPostalCode (code) {\n        this.setParameter(OASISAddress.KEY_POSTAL_CODE, code);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPostalCode () {\n        return this.getParameter(OASISAddress.KEY_POSTAL_CODE);\n    }\n\n    /**\n     * @param {String} area - Portion of country (e.g. state)\n     * @return {OASISAddress}\n     */\n    setAdministrativeArea (area) {\n        this.setParameter(OASISAddress.KEY_ADMINISTRATIVE_AREA, area);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAdministrativeArea () {\n        return this.getParameter(OASISAddress.KEY_ADMINISTRATIVE_AREA);\n    }\n\n    /**\n     * @param {String} area - Portion of e.g. state (e.g. county)\n     * @return {OASISAddress}\n     */\n    setSubAdministrativeArea (area) {\n        this.setParameter(OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA, area);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSubAdministrativeArea () {\n        return this.getParameter(OASISAddress.KEY_SUB_ADMINISTRATIVE_AREA);\n    }\n\n    /**\n     * @param {String} locality - Hypernym for e.g. city/village\n     * @return {OASISAddress}\n     */\n    setLocality (locality) {\n        this.setParameter(OASISAddress.KEY_LOCALITY, locality);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getLocality () {\n        return this.getParameter(OASISAddress.KEY_LOCALITY);\n    }\n\n    /**\n     * @param {String} locality - Hypernym for e.g. district\n     * @return {OASISAddress}\n     */\n    setSubLocality (locality) {\n        this.setParameter(OASISAddress.KEY_SUB_LOCALITY, locality);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSubLocality () {\n        return this.getParameter(OASISAddress.KEY_SUB_LOCALITY);\n    }\n\n    /**\n     * @param {String} thoroughfare - Hypernym for street, road etc.\n     * @return {OASISAddress}\n     */\n    setThoroughfare (thoroughfare) {\n        this.setParameter(OASISAddress.KEY_THOROUGHFARE, thoroughfare);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getThoroughfare () {\n        return this.getParameter(OASISAddress.KEY_THOROUGHFARE);\n    }\n\n    /**\n     * @param {String} thoroughfare - Portion of thoroughfare e.g. house number\n     * @return {OASISAddress}\n     */\n    setSubThoroughfare (thoroughfare) {\n        this.setParameter(OASISAddress.KEY_SUB_THOROUGHFARE, thoroughfare);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSubThoroughfare () {\n        return this.getParameter(OASISAddress.KEY_SUB_THOROUGHFARE);\n    }\n}\n\nOASISAddress.KEY_COUNTRY_NAME = 'countryName';\nOASISAddress.KEY_COUNTRY_CODE = 'countryCode';\nOASISAddress.KEY_POSTAL_CODE = 'postalCode';\nOASISAddress.KEY_ADMINISTRATIVE_AREA = 'administrativeArea';\nOASISAddress.KEY_SUB_ADMINISTRATIVE_AREA = 'subAdministrativeArea';\nOASISAddress.KEY_LOCALITY = 'locality';\nOASISAddress.KEY_SUB_LOCALITY = 'subLocality';\nOASISAddress.KEY_THOROUGHFARE = 'thoroughfare';\nOASISAddress.KEY_SUB_THOROUGHFARE = 'subThoroughfare';\n\nexport { OASISAddress };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { DeliveryMode } from '../enums/DeliveryMode.js';\nimport { DateTime } from '../structs/DateTime.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { OASISAddress } from '../structs/OASISAddress.js';\nimport { Image } from '../structs/Image.js';\n\nclass SendLocation extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SendLocation);\n    }\n\n    /**\n     * @param {Number} degrees\n     * @return {SendLocation}\n     */\n    setLongitudeDegrees (degrees) {\n        this.setParameter(SendLocation.KEY_LONGITUDE_DEGREES, degrees);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLongitudeDegrees () {\n        return this.getParameter(SendLocation.KEY_LONGITUDE_DEGREES);\n    }\n\n    /**\n     * @param {Number} degrees\n     * @return {SendLocation}\n     */\n    setLatitudeDegrees (degrees) {\n        this.setParameter(SendLocation.KEY_LATITUDE_DEGREES, degrees);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLatitudeDegrees () {\n        return this.getParameter(SendLocation.KEY_LATITUDE_DEGREES);\n    }\n\n    /**\n     * @param {String} name - Name / title of intended location\n     * @return {SendLocation}\n     */\n    setLocationName (name) {\n        this.setParameter(SendLocation.KEY_LOCATION_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getLocationName () {\n        return this.getParameter(SendLocation.KEY_LOCATION_NAME);\n    }\n\n    /**\n     * @param {String} description - Description intended location / establishment (if applicable)\n     * @return {SendLocation}\n     */\n    setLocationDescription (description) {\n        this.setParameter(SendLocation.KEY_LOCATION_DESCRIPTION, description);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getLocationDescription () {\n        return this.getParameter(SendLocation.KEY_LOCATION_DESCRIPTION);\n    }\n\n    /**\n     * @param {String[]} lines - Location address (if applicable)\n     * @return {SendLocation}\n     */\n    setAddressLines (lines) {\n        this.setParameter(SendLocation.KEY_ADDRESS_LINES, lines);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getAddressLines () {\n        return this.getParameter(SendLocation.KEY_ADDRESS_LINES);\n    }\n\n    /**\n     * @param {String} number - Phone number of intended location / establishment (if applicable)\n     * @return {SendLocation}\n     */\n    setPhoneNumber (number) {\n        this.setParameter(SendLocation.KEY_PHONE_NUMBER, number);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPhoneNumber () {\n        return this.getParameter(SendLocation.KEY_PHONE_NUMBER);\n    }\n\n    /**\n     * @param {Image} image - Image / icon of intended location (if applicable and supported)\n     * @return {SendLocation}\n     */\n    setLocationImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(SendLocation.KEY_LOCATION_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getLocationImage () {\n        return this.getObject(Image, SendLocation.KEY_LOCATION_IMAGE);\n    }\n\n    /**\n     * @param {DateTime} stamp - timestamp in ISO 8601 format\n     * @return {SendLocation}\n     */\n    setTimeStamp (stamp) {\n        this.validateType(DateTime, stamp);\n        this.setParameter(SendLocation.KEY_TIME_STAMP, stamp);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getTimeStamp () {\n        return this.getObject(DateTime, SendLocation.KEY_TIME_STAMP);\n    }\n\n    /**\n     * @param {OASISAddress} address - Address to be used for setting destination\n     * @return {SendLocation}\n     */\n    setAddress (address) {\n        this.validateType(OASISAddress, address);\n        this.setParameter(SendLocation.KEY_ADDRESS, address);\n        return this;\n    }\n\n    /**\n     * @return {OASISAddress}\n     */\n    getAddress () {\n        return this.getObject(OASISAddress, SendLocation.KEY_ADDRESS);\n    }\n\n    /**\n     * @param {DeliveryMode} mode - Defines the mode of prompt for user\n     * @return {SendLocation}\n     */\n    setDeliveryMode (mode) {\n        this.validateType(DeliveryMode, mode);\n        this.setParameter(SendLocation.KEY_DELIVERY_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {DeliveryMode}\n     */\n    getDeliveryMode () {\n        return this.getObject(DeliveryMode, SendLocation.KEY_DELIVERY_MODE);\n    }\n}\n\nSendLocation.KEY_LONGITUDE_DEGREES = 'longitudeDegrees';\nSendLocation.KEY_LATITUDE_DEGREES = 'latitudeDegrees';\nSendLocation.KEY_LOCATION_NAME = 'locationName';\nSendLocation.KEY_LOCATION_DESCRIPTION = 'locationDescription';\nSendLocation.KEY_ADDRESS_LINES = 'addressLines';\nSendLocation.KEY_PHONE_NUMBER = 'phoneNumber';\nSendLocation.KEY_LOCATION_IMAGE = 'locationImage';\nSendLocation.KEY_TIME_STAMP = 'timeStamp';\nSendLocation.KEY_ADDRESS = 'address';\nSendLocation.KEY_DELIVERY_MODE = 'deliveryMode';\n\nexport { SendLocation };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SendLocationResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SendLocation);\n    }\n}\n\n\nexport { SendLocationResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Dials a phone number and switches to phone application.\n */\nclass DialNumber extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DialNumber);\n    }\n\n    /**\n     * @param {String} number - Phone number is a string, which can be up to 40 chars. All characters shall be stripped\n     *                          from string except digits 0-9 and * # , ; +\n     * @return {DialNumber}\n     */\n    setNumber (number) {\n        this.setParameter(DialNumber.KEY_NUMBER, number);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getNumber () {\n        return this.getParameter(DialNumber.KEY_NUMBER);\n    }\n}\n\nDialNumber.KEY_NUMBER = 'number';\n\nexport { DialNumber };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass DialNumberResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.DialNumber);\n    }\n}\n\n\nexport { DialNumberResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ButtonPressMode\n * @property {Object} _MAP\n */\nclass ButtonPressMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * A button was released, after it was pressed for a long time Actual timing is defined by the headunit and may\n     * vary\n     * @return {String}\n     */\n    static get LONG () {\n        return ButtonPressMode._MAP.LONG;\n    }\n\n    /**\n     * A button was released, after it was pressed for a short time Actual timing is defined by the headunit and may\n     * vary\n     * @return {String}\n     */\n    static get SHORT () {\n        return ButtonPressMode._MAP.SHORT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ButtonPressMode._valueForKey(key, ButtonPressMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ButtonPressMode._keyForValue(value, ButtonPressMode._MAP);\n    }\n}\n\nButtonPressMode._MAP = Object.freeze({\n    'LONG': 'LONG',\n    'SHORT': 'SHORT',\n});\n\nexport { ButtonPressMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ModuleType\n * @property {Object} _MAP\n */\nclass ModuleType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLIMATE () {\n        return ModuleType._MAP.CLIMATE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RADIO () {\n        return ModuleType._MAP.RADIO;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEAT () {\n        return ModuleType._MAP.SEAT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIO () {\n        return ModuleType._MAP.AUDIO;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LIGHT () {\n        return ModuleType._MAP.LIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_SETTINGS () {\n        return ModuleType._MAP.HMI_SETTINGS;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ModuleType._valueForKey(key, ModuleType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ModuleType._keyForValue(value, ModuleType._MAP);\n    }\n}\n\nModuleType._MAP = Object.freeze({\n    'CLIMATE': 'CLIMATE',\n    'RADIO': 'RADIO',\n    'SEAT': 'SEAT',\n    'AUDIO': 'AUDIO',\n    'LIGHT': 'LIGHT',\n    'HMI_SETTINGS': 'HMI_SETTINGS',\n});\n\nexport { ModuleType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ButtonName } from '../enums/ButtonName.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ButtonPressMode } from '../enums/ButtonPressMode.js';\nimport { ModuleType } from '../enums/ModuleType.js';\nimport { RpcRequest } from '../RpcRequest.js';\n\nclass ButtonPress extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ButtonPress);\n    }\n\n    /**\n     * @param {ModuleType} type - The module where the button should be pressed\n     * @return {ButtonPress}\n     */\n    setModuleType (type) {\n        this.validateType(ModuleType, type);\n        this.setParameter(ButtonPress.KEY_MODULE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {ModuleType}\n     */\n    getModuleType () {\n        return this.getObject(ModuleType, ButtonPress.KEY_MODULE_TYPE);\n    }\n\n    /**\n     * @param {String} id - Id of a module, published by System Capability.\n     * @return {ButtonPress}\n     */\n    setModuleId (id) {\n        this.setParameter(ButtonPress.KEY_MODULE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleId () {\n        return this.getParameter(ButtonPress.KEY_MODULE_ID);\n    }\n\n    /**\n     * @param {ButtonName} name - The name of supported RC climate or radio button.\n     * @return {ButtonPress}\n     */\n    setButtonName (name) {\n        this.validateType(ButtonName, name);\n        this.setParameter(ButtonPress.KEY_BUTTON_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {ButtonName}\n     */\n    getButtonName () {\n        return this.getObject(ButtonName, ButtonPress.KEY_BUTTON_NAME);\n    }\n\n    /**\n     * @param {ButtonPressMode} mode - Indicates whether this is a LONG or SHORT button press event.\n     * @return {ButtonPress}\n     */\n    setButtonPressMode (mode) {\n        this.validateType(ButtonPressMode, mode);\n        this.setParameter(ButtonPress.KEY_BUTTON_PRESS_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {ButtonPressMode}\n     */\n    getButtonPressMode () {\n        return this.getObject(ButtonPressMode, ButtonPress.KEY_BUTTON_PRESS_MODE);\n    }\n}\n\nButtonPress.KEY_MODULE_TYPE = 'moduleType';\nButtonPress.KEY_MODULE_ID = 'moduleId';\nButtonPress.KEY_BUTTON_NAME = 'buttonName';\nButtonPress.KEY_BUTTON_PRESS_MODE = 'buttonPressMode';\n\nexport { ButtonPress };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ButtonPressResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ButtonPress);\n    }\n}\n\n\nexport { ButtonPressResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ModuleType } from '../enums/ModuleType.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass GetInteriorVehicleData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetInteriorVehicleData);\n    }\n\n    /**\n     * @param {ModuleType} type - The type of a RC module to retrieve module data from the vehicle. In the future, this\n     *                            should be the Identification of a module.\n     * @return {GetInteriorVehicleData}\n     */\n    setModuleType (type) {\n        this.validateType(ModuleType, type);\n        this.setParameter(GetInteriorVehicleData.KEY_MODULE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {ModuleType}\n     */\n    getModuleType () {\n        return this.getObject(ModuleType, GetInteriorVehicleData.KEY_MODULE_TYPE);\n    }\n\n    /**\n     * @param {String} id - Id of a module, published by System Capability.\n     * @return {GetInteriorVehicleData}\n     */\n    setModuleId (id) {\n        this.setParameter(GetInteriorVehicleData.KEY_MODULE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleId () {\n        return this.getParameter(GetInteriorVehicleData.KEY_MODULE_ID);\n    }\n\n    /**\n     * @param {Boolean} subscribe - If subscribe is true, the head unit will register OnInteriorVehicleData\n     *                              notifications for the requested module (moduleId and moduleType). If subscribe is\n     *                              false, the head unit will unregister OnInteriorVehicleData notifications for the\n     *                              requested module (moduleId and moduleType). If subscribe is not included, the\n     *                              subscription status of the app for the requested module (moduleId and moduleType)\n     *                              will remain unchanged.\n     * @return {GetInteriorVehicleData}\n     */\n    setSubscribe (subscribe) {\n        this.setParameter(GetInteriorVehicleData.KEY_SUBSCRIBE, subscribe);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSubscribe () {\n        return this.getParameter(GetInteriorVehicleData.KEY_SUBSCRIBE);\n    }\n}\n\nGetInteriorVehicleData.KEY_MODULE_TYPE = 'moduleType';\nGetInteriorVehicleData.KEY_MODULE_ID = 'moduleId';\nGetInteriorVehicleData.KEY_SUBSCRIBE = 'subscribe';\n\nexport { GetInteriorVehicleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} DisplayMode\n * @property {Object} _MAP\n */\nclass DisplayMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DAY () {\n        return DisplayMode._MAP.DAY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NIGHT () {\n        return DisplayMode._MAP.NIGHT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUTO () {\n        return DisplayMode._MAP.AUTO;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return DisplayMode._valueForKey(key, DisplayMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return DisplayMode._keyForValue(value, DisplayMode._MAP);\n    }\n}\n\nDisplayMode._MAP = Object.freeze({\n    'DAY': 'DAY',\n    'NIGHT': 'NIGHT',\n    'AUTO': 'AUTO',\n});\n\nexport { DisplayMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} DistanceUnit\n * @property {Object} _MAP\n */\nclass DistanceUnit extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MILES () {\n        return DistanceUnit._MAP.MILES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get KILOMETERS () {\n        return DistanceUnit._MAP.KILOMETERS;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return DistanceUnit._valueForKey(key, DistanceUnit._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return DistanceUnit._keyForValue(value, DistanceUnit._MAP);\n    }\n}\n\nDistanceUnit._MAP = Object.freeze({\n    'MILES': 'MILES',\n    'KILOMETERS': 'KILOMETERS',\n});\n\nexport { DistanceUnit };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TemperatureUnit\n * @property {Object} _MAP\n */\nclass TemperatureUnit extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FAHRENHEIT () {\n        return TemperatureUnit._MAP.FAHRENHEIT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CELSIUS () {\n        return TemperatureUnit._MAP.CELSIUS;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TemperatureUnit._valueForKey(key, TemperatureUnit._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TemperatureUnit._keyForValue(value, TemperatureUnit._MAP);\n    }\n}\n\nTemperatureUnit._MAP = Object.freeze({\n    'FAHRENHEIT': 'FAHRENHEIT',\n    'CELSIUS': 'CELSIUS',\n});\n\nexport { TemperatureUnit };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { DisplayMode } from '../enums/DisplayMode.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { DistanceUnit } from '../enums/DistanceUnit.js';\nimport { TemperatureUnit } from '../enums/TemperatureUnit.js';\n\n/**\n * Corresponds to \"HMI_SETTINGS\" ModuleType\n */\nclass HMISettingsControlData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {DisplayMode} mode\n     * @return {HMISettingsControlData}\n     */\n    setDisplayMode (mode) {\n        this.validateType(DisplayMode, mode);\n        this.setParameter(HMISettingsControlData.KEY_DISPLAY_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {DisplayMode}\n     */\n    getDisplayMode () {\n        return this.getObject(DisplayMode, HMISettingsControlData.KEY_DISPLAY_MODE);\n    }\n\n    /**\n     * @param {TemperatureUnit} unit\n     * @return {HMISettingsControlData}\n     */\n    setTemperatureUnit (unit) {\n        this.validateType(TemperatureUnit, unit);\n        this.setParameter(HMISettingsControlData.KEY_TEMPERATURE_UNIT, unit);\n        return this;\n    }\n\n    /**\n     * @return {TemperatureUnit}\n     */\n    getTemperatureUnit () {\n        return this.getObject(TemperatureUnit, HMISettingsControlData.KEY_TEMPERATURE_UNIT);\n    }\n\n    /**\n     * @param {DistanceUnit} unit\n     * @return {HMISettingsControlData}\n     */\n    setDistanceUnit (unit) {\n        this.validateType(DistanceUnit, unit);\n        this.setParameter(HMISettingsControlData.KEY_DISTANCE_UNIT, unit);\n        return this;\n    }\n\n    /**\n     * @return {DistanceUnit}\n     */\n    getDistanceUnit () {\n        return this.getObject(DistanceUnit, HMISettingsControlData.KEY_DISTANCE_UNIT);\n    }\n}\n\nHMISettingsControlData.KEY_DISPLAY_MODE = 'displayMode';\nHMISettingsControlData.KEY_TEMPERATURE_UNIT = 'temperatureUnit';\nHMISettingsControlData.KEY_DISTANCE_UNIT = 'distanceUnit';\n\nexport { HMISettingsControlData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} RadioBand\n * @property {Object} _MAP\n */\nclass RadioBand extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AM () {\n        return RadioBand._MAP.AM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FM () {\n        return RadioBand._MAP.FM;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get XM () {\n        return RadioBand._MAP.XM;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return RadioBand._valueForKey(key, RadioBand._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return RadioBand._keyForValue(value, RadioBand._MAP);\n    }\n}\n\nRadioBand._MAP = Object.freeze({\n    'AM': 'AM',\n    'FM': 'FM',\n    'XM': 'XM',\n});\n\nexport { RadioBand };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass RdsData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} ps - Program Service Name\n     * @return {RdsData}\n     */\n    setPS (ps) {\n        this.setParameter(RdsData.KEY_PS, ps);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPS () {\n        return this.getParameter(RdsData.KEY_PS);\n    }\n\n    /**\n     * @param {String} rt - Radio Text\n     * @return {RdsData}\n     */\n    setRT (rt) {\n        this.setParameter(RdsData.KEY_RT, rt);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getRT () {\n        return this.getParameter(RdsData.KEY_RT);\n    }\n\n    /**\n     * @param {String} ct - The clock text in UTC format as YYYY-MM-DDThh:mm:ss.sTZD\n     * @return {RdsData}\n     */\n    setCT (ct) {\n        this.setParameter(RdsData.KEY_CT, ct);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getCT () {\n        return this.getParameter(RdsData.KEY_CT);\n    }\n\n    /**\n     * @param {String} pi - Program Identification - the call sign for the radio station\n     * @return {RdsData}\n     */\n    setPI (pi) {\n        this.setParameter(RdsData.KEY_PI, pi);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPI () {\n        return this.getParameter(RdsData.KEY_PI);\n    }\n\n    /**\n     * @param {Number} pty - The program type - The region should be used to differentiate between EU and North America\n     *                       program types\n     * @return {RdsData}\n     */\n    setPTY (pty) {\n        this.setParameter(RdsData.KEY_PTY, pty);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPTY () {\n        return this.getParameter(RdsData.KEY_PTY);\n    }\n\n    /**\n     * @param {Boolean} tp - Traffic Program Identification - Identifies a station that offers traffic\n     * @return {RdsData}\n     */\n    setTP (tp) {\n        this.setParameter(RdsData.KEY_TP, tp);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTP () {\n        return this.getParameter(RdsData.KEY_TP);\n    }\n\n    /**\n     * @param {Boolean} ta - Traffic Announcement Identification - Indicates an ongoing traffic announcement\n     * @return {RdsData}\n     */\n    setTA (ta) {\n        this.setParameter(RdsData.KEY_TA, ta);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTA () {\n        return this.getParameter(RdsData.KEY_TA);\n    }\n\n    /**\n     * @param {String} reg - Region\n     * @return {RdsData}\n     */\n    setREG (reg) {\n        this.setParameter(RdsData.KEY_REG, reg);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getREG () {\n        return this.getParameter(RdsData.KEY_REG);\n    }\n}\n\nRdsData.KEY_PS = 'PS';\nRdsData.KEY_RT = 'RT';\nRdsData.KEY_CT = 'CT';\nRdsData.KEY_PI = 'PI';\nRdsData.KEY_PTY = 'PTY';\nRdsData.KEY_TP = 'TP';\nRdsData.KEY_TA = 'TA';\nRdsData.KEY_REG = 'REG';\n\nexport { RdsData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} RadioState\n * @property {Object} _MAP\n */\nclass RadioState extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ACQUIRING () {\n        return RadioState._MAP.ACQUIRING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ACQUIRED () {\n        return RadioState._MAP.ACQUIRED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MULTICAST () {\n        return RadioState._MAP.MULTICAST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NOT_FOUND () {\n        return RadioState._MAP.NOT_FOUND;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return RadioState._valueForKey(key, RadioState._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return RadioState._keyForValue(value, RadioState._MAP);\n    }\n}\n\nRadioState._MAP = Object.freeze({\n    'ACQUIRING': 'ACQUIRING',\n    'ACQUIRED': 'ACQUIRED',\n    'MULTICAST': 'MULTICAST',\n    'NOT_FOUND': 'NOT_FOUND',\n});\n\nexport { RadioState };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass StationIDNumber extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} code - Binary Representation of ITU Country Code. USA Code is 001.\n     * @return {StationIDNumber}\n     */\n    setCountryCode (code) {\n        this.setParameter(StationIDNumber.KEY_COUNTRY_CODE, code);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCountryCode () {\n        return this.getParameter(StationIDNumber.KEY_COUNTRY_CODE);\n    }\n\n    /**\n     * @param {Number} id - Binary representation of unique facility ID assigned by the FCC; FCC controlled for U.S.\n     *                      territory\n     * @return {StationIDNumber}\n     */\n    setFccFacilityId (id) {\n        this.setParameter(StationIDNumber.KEY_FCC_FACILITY_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFccFacilityId () {\n        return this.getParameter(StationIDNumber.KEY_FCC_FACILITY_ID);\n    }\n}\n\nStationIDNumber.KEY_COUNTRY_CODE = 'countryCode';\nStationIDNumber.KEY_FCC_FACILITY_ID = 'fccFacilityId';\n\nexport { StationIDNumber };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { GPSData } from './GPSData.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { StationIDNumber } from './StationIDNumber.js';\n\nclass SisData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - Identifies the 4-alpha-character station call sign plus an optional (-FM) extension\n     * @return {SisData}\n     */\n    setStationShortName (name) {\n        this.setParameter(SisData.KEY_STATION_SHORT_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getStationShortName () {\n        return this.getParameter(SisData.KEY_STATION_SHORT_NAME);\n    }\n\n    /**\n     * @param {StationIDNumber} number - Used for network Application. Consists of Country Code and FCC Facility ID.\n     * @return {SisData}\n     */\n    setStationIDNumber (number) {\n        this.validateType(StationIDNumber, number);\n        this.setParameter(SisData.KEY_STATION_IDNUMBER, number);\n        return this;\n    }\n\n    /**\n     * @return {StationIDNumber}\n     */\n    getStationIDNumber () {\n        return this.getObject(StationIDNumber, SisData.KEY_STATION_IDNUMBER);\n    }\n\n    /**\n     * @param {String} name - Identifies the station call sign or other identifying information in the long format.\n     * @return {SisData}\n     */\n    setStationLongName (name) {\n        this.setParameter(SisData.KEY_STATION_LONG_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getStationLongName () {\n        return this.getParameter(SisData.KEY_STATION_LONG_NAME);\n    }\n\n    /**\n     * @param {GPSData} location - Provides the 3-dimensional geographic station location.\n     * @return {SisData}\n     */\n    setStationLocation (location) {\n        this.validateType(GPSData, location);\n        this.setParameter(SisData.KEY_STATION_LOCATION, location);\n        return this;\n    }\n\n    /**\n     * @return {GPSData}\n     */\n    getStationLocation () {\n        return this.getObject(GPSData, SisData.KEY_STATION_LOCATION);\n    }\n\n    /**\n     * @param {String} message - May be used to convey textual information of general interest to the consumer such as\n     *                           weather forecasts or public service announcements. Includes a high priority delivery\n     *                           feature to convey emergencies that may be in the listening area.\n     * @return {SisData}\n     */\n    setStationMessage (message) {\n        this.setParameter(SisData.KEY_STATION_MESSAGE, message);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getStationMessage () {\n        return this.getParameter(SisData.KEY_STATION_MESSAGE);\n    }\n}\n\nSisData.KEY_STATION_SHORT_NAME = 'stationShortName';\nSisData.KEY_STATION_IDNUMBER = 'stationIDNumber';\nSisData.KEY_STATION_LONG_NAME = 'stationLongName';\nSisData.KEY_STATION_LOCATION = 'stationLocation';\nSisData.KEY_STATION_MESSAGE = 'stationMessage';\n\nexport { SisData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RadioBand } from '../enums/RadioBand.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { RdsData } from './RdsData.js';\nimport { RadioState } from '../enums/RadioState.js';\nimport { SisData } from './SisData.js';\n\nclass RadioControlData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} integer - The integer part of the frequency ie for 101.7 this value should be 101\n     * @return {RadioControlData}\n     */\n    setFrequencyInteger (integer) {\n        this.setParameter(RadioControlData.KEY_FREQUENCY_INTEGER, integer);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFrequencyInteger () {\n        return this.getParameter(RadioControlData.KEY_FREQUENCY_INTEGER);\n    }\n\n    /**\n     * @param {Number} fraction - The fractional part of the frequency for 101.7 is 7\n     * @return {RadioControlData}\n     */\n    setFrequencyFraction (fraction) {\n        this.setParameter(RadioControlData.KEY_FREQUENCY_FRACTION, fraction);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFrequencyFraction () {\n        return this.getParameter(RadioControlData.KEY_FREQUENCY_FRACTION);\n    }\n\n    /**\n     * @param {RadioBand} band\n     * @return {RadioControlData}\n     */\n    setBand (band) {\n        this.validateType(RadioBand, band);\n        this.setParameter(RadioControlData.KEY_BAND, band);\n        return this;\n    }\n\n    /**\n     * @return {RadioBand}\n     */\n    getBand () {\n        return this.getObject(RadioBand, RadioControlData.KEY_BAND);\n    }\n\n    /**\n     * @param {RdsData} data\n     * @return {RadioControlData}\n     */\n    setRdsData (data) {\n        this.validateType(RdsData, data);\n        this.setParameter(RadioControlData.KEY_RDS_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {RdsData}\n     */\n    getRdsData () {\n        return this.getObject(RdsData, RadioControlData.KEY_RDS_DATA);\n    }\n\n    /**\n     * @param {Boolean} enable - True if the hd radio is on, false if the radio is off\n     * @return {RadioControlData}\n     */\n    setHdRadioEnable (enable) {\n        this.setParameter(RadioControlData.KEY_HD_RADIO_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHdRadioEnable () {\n        return this.getParameter(RadioControlData.KEY_HD_RADIO_ENABLE);\n    }\n\n    /**\n     * @param {Number} ds - Number of HD sub-channels if available\n     * @return {RadioControlData}\n     */\n    setAvailableHDs (ds) {\n        this.setParameter(RadioControlData.KEY_AVAILABLE_HDS, ds);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getAvailableHDs () {\n        return this.getParameter(RadioControlData.KEY_AVAILABLE_HDS);\n    }\n\n    /**\n     * @param {Number[]} channels - The list of available HD sub-channel indexes. Empty list means no Hd channel is\n     *                              available. Read-only.\n     * @return {RadioControlData}\n     */\n    setAvailableHdChannels (channels) {\n        this.setParameter(RadioControlData.KEY_AVAILABLE_HD_CHANNELS, channels);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getAvailableHdChannels () {\n        return this.getParameter(RadioControlData.KEY_AVAILABLE_HD_CHANNELS);\n    }\n\n    /**\n     * @param {Number} channel - Current HD sub-channel if available\n     * @return {RadioControlData}\n     */\n    setHdChannel (channel) {\n        this.setParameter(RadioControlData.KEY_HD_CHANNEL, channel);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHdChannel () {\n        return this.getParameter(RadioControlData.KEY_HD_CHANNEL);\n    }\n\n    /**\n     * @param {Number} strength\n     * @return {RadioControlData}\n     */\n    setSignalStrength (strength) {\n        this.setParameter(RadioControlData.KEY_SIGNAL_STRENGTH, strength);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSignalStrength () {\n        return this.getParameter(RadioControlData.KEY_SIGNAL_STRENGTH);\n    }\n\n    /**\n     * @param {Number} threshold - If the signal strength falls below the set value for this parameter, the radio will\n     *                             tune to an alternative frequency\n     * @return {RadioControlData}\n     */\n    setSignalChangeThreshold (threshold) {\n        this.setParameter(RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD, threshold);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSignalChangeThreshold () {\n        return this.getParameter(RadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD);\n    }\n\n    /**\n     * @param {Boolean} enable - True if the radio is on, false if the radio is off. If set to false, no other data will\n     *                           be included.\n     * @return {RadioControlData}\n     */\n    setRadioEnable (enable) {\n        this.setParameter(RadioControlData.KEY_RADIO_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRadioEnable () {\n        return this.getParameter(RadioControlData.KEY_RADIO_ENABLE);\n    }\n\n    /**\n     * @param {RadioState} state\n     * @return {RadioControlData}\n     */\n    setState (state) {\n        this.validateType(RadioState, state);\n        this.setParameter(RadioControlData.KEY_STATE, state);\n        return this;\n    }\n\n    /**\n     * @return {RadioState}\n     */\n    getState () {\n        return this.getObject(RadioState, RadioControlData.KEY_STATE);\n    }\n\n    /**\n     * @param {SisData} data - Read-only Station Information Service (SIS) data provides basic information about the\n     *                         station such as call sign, as well as information not displayable to the consumer such as\n     *                         the station identification number\n     * @return {RadioControlData}\n     */\n    setSisData (data) {\n        this.validateType(SisData, data);\n        this.setParameter(RadioControlData.KEY_SIS_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {SisData}\n     */\n    getSisData () {\n        return this.getObject(SisData, RadioControlData.KEY_SIS_DATA);\n    }\n}\n\nRadioControlData.KEY_FREQUENCY_INTEGER = 'frequencyInteger';\nRadioControlData.KEY_FREQUENCY_FRACTION = 'frequencyFraction';\nRadioControlData.KEY_BAND = 'band';\nRadioControlData.KEY_RDS_DATA = 'rdsData';\nRadioControlData.KEY_HD_RADIO_ENABLE = 'hdRadioEnable';\nRadioControlData.KEY_AVAILABLE_HDS = 'availableHDs';\nRadioControlData.KEY_AVAILABLE_HD_CHANNELS = 'availableHdChannels';\nRadioControlData.KEY_HD_CHANNEL = 'hdChannel';\nRadioControlData.KEY_SIGNAL_STRENGTH = 'signalStrength';\nRadioControlData.KEY_SIGNAL_CHANGE_THRESHOLD = 'signalChangeThreshold';\nRadioControlData.KEY_RADIO_ENABLE = 'radioEnable';\nRadioControlData.KEY_STATE = 'state';\nRadioControlData.KEY_SIS_DATA = 'sisData';\n\nexport { RadioControlData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { TemperatureUnit } from '../enums/TemperatureUnit.js';\n\nclass Temperature extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {TemperatureUnit} unit - Temperature Unit\n     * @return {Temperature}\n     */\n    setUnit (unit) {\n        this.validateType(TemperatureUnit, unit);\n        this.setParameter(Temperature.KEY_UNIT, unit);\n        return this;\n    }\n\n    /**\n     * @return {TemperatureUnit}\n     */\n    getUnit () {\n        return this.getObject(TemperatureUnit, Temperature.KEY_UNIT);\n    }\n\n    /**\n     * @param {Number} value - Temperature Value in TemperatureUnit specified unit. Range depends on OEM and is not\n     *                         checked by SDL.\n     * @return {Temperature}\n     */\n    setValue (value) {\n        this.setParameter(Temperature.KEY_VALUE, value);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getValue () {\n        return this.getParameter(Temperature.KEY_VALUE);\n    }\n}\n\nTemperature.KEY_UNIT = 'unit';\nTemperature.KEY_VALUE = 'value';\n\nexport { Temperature };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} VentilationMode\n * @property {Object} _MAP\n */\nclass VentilationMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UPPER () {\n        return VentilationMode._MAP.UPPER;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LOWER () {\n        return VentilationMode._MAP.LOWER;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BOTH () {\n        return VentilationMode._MAP.BOTH;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NONE () {\n        return VentilationMode._MAP.NONE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VentilationMode._valueForKey(key, VentilationMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VentilationMode._keyForValue(value, VentilationMode._MAP);\n    }\n}\n\nVentilationMode._MAP = Object.freeze({\n    'UPPER': 'UPPER',\n    'LOWER': 'LOWER',\n    'BOTH': 'BOTH',\n    'NONE': 'NONE',\n});\n\nexport { VentilationMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} DefrostZone\n * @property {Object} _MAP\n */\nclass DefrostZone extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FRONT () {\n        return DefrostZone._MAP.FRONT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REAR () {\n        return DefrostZone._MAP.REAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ALL () {\n        return DefrostZone._MAP.ALL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NONE () {\n        return DefrostZone._MAP.NONE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return DefrostZone._valueForKey(key, DefrostZone._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return DefrostZone._keyForValue(value, DefrostZone._MAP);\n    }\n}\n\nDefrostZone._MAP = Object.freeze({\n    'FRONT': 'FRONT',\n    'REAR': 'REAR',\n    'ALL': 'ALL',\n    'NONE': 'NONE',\n});\n\nexport { DefrostZone };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Temperature } from './Temperature.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VentilationMode } from '../enums/VentilationMode.js';\nimport { DefrostZone } from '../enums/DefrostZone.js';\n\nclass ClimateControlData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} speed\n     * @return {ClimateControlData}\n     */\n    setFanSpeed (speed) {\n        this.setParameter(ClimateControlData.KEY_FAN_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFanSpeed () {\n        return this.getParameter(ClimateControlData.KEY_FAN_SPEED);\n    }\n\n    /**\n     * @param {Temperature} temperature\n     * @return {ClimateControlData}\n     */\n    setCurrentTemperature (temperature) {\n        this.validateType(Temperature, temperature);\n        this.setParameter(ClimateControlData.KEY_CURRENT_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getCurrentTemperature () {\n        return this.getObject(Temperature, ClimateControlData.KEY_CURRENT_TEMPERATURE);\n    }\n\n    /**\n     * @param {Temperature} temperature\n     * @return {ClimateControlData}\n     */\n    setDesiredTemperature (temperature) {\n        this.validateType(Temperature, temperature);\n        this.setParameter(ClimateControlData.KEY_DESIRED_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getDesiredTemperature () {\n        return this.getObject(Temperature, ClimateControlData.KEY_DESIRED_TEMPERATURE);\n    }\n\n    /**\n     * @param {Boolean} enable\n     * @return {ClimateControlData}\n     */\n    setAcEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_AC_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAcEnable () {\n        return this.getParameter(ClimateControlData.KEY_AC_ENABLE);\n    }\n\n    /**\n     * @param {Boolean} enable\n     * @return {ClimateControlData}\n     */\n    setCirculateAirEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_CIRCULATE_AIR_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCirculateAirEnable () {\n        return this.getParameter(ClimateControlData.KEY_CIRCULATE_AIR_ENABLE);\n    }\n\n    /**\n     * @param {Boolean} enable\n     * @return {ClimateControlData}\n     */\n    setAutoModeEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_AUTO_MODE_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAutoModeEnable () {\n        return this.getParameter(ClimateControlData.KEY_AUTO_MODE_ENABLE);\n    }\n\n    /**\n     * @param {DefrostZone} zone\n     * @return {ClimateControlData}\n     */\n    setDefrostZone (zone) {\n        this.validateType(DefrostZone, zone);\n        this.setParameter(ClimateControlData.KEY_DEFROST_ZONE, zone);\n        return this;\n    }\n\n    /**\n     * @return {DefrostZone}\n     */\n    getDefrostZone () {\n        return this.getObject(DefrostZone, ClimateControlData.KEY_DEFROST_ZONE);\n    }\n\n    /**\n     * @param {Boolean} enable\n     * @return {ClimateControlData}\n     */\n    setDualModeEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_DUAL_MODE_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDualModeEnable () {\n        return this.getParameter(ClimateControlData.KEY_DUAL_MODE_ENABLE);\n    }\n\n    /**\n     * @param {Boolean} enable\n     * @return {ClimateControlData}\n     */\n    setAcMaxEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_AC_MAX_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAcMaxEnable () {\n        return this.getParameter(ClimateControlData.KEY_AC_MAX_ENABLE);\n    }\n\n    /**\n     * @param {VentilationMode} mode\n     * @return {ClimateControlData}\n     */\n    setVentilationMode (mode) {\n        this.validateType(VentilationMode, mode);\n        this.setParameter(ClimateControlData.KEY_VENTILATION_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {VentilationMode}\n     */\n    getVentilationMode () {\n        return this.getObject(VentilationMode, ClimateControlData.KEY_VENTILATION_MODE);\n    }\n\n    /**\n     * @param {Boolean} enable - value false means disabled/turn off, value true means enabled/turn on.\n     * @return {ClimateControlData}\n     */\n    setHeatedSteeringWheelEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedSteeringWheelEnable () {\n        return this.getParameter(ClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE);\n    }\n\n    /**\n     * @param {Boolean} enable - value false means disabled, value true means enabled.\n     * @return {ClimateControlData}\n     */\n    setHeatedWindshieldEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedWindshieldEnable () {\n        return this.getParameter(ClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE);\n    }\n\n    /**\n     * @param {Boolean} enable - value false means disabled, value true means enabled.\n     * @return {ClimateControlData}\n     */\n    setHeatedRearWindowEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedRearWindowEnable () {\n        return this.getParameter(ClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE);\n    }\n\n    /**\n     * @param {Boolean} enable - value false means disabled, value true means enabled.\n     * @return {ClimateControlData}\n     */\n    setHeatedMirrorsEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_HEATED_MIRRORS_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedMirrorsEnable () {\n        return this.getParameter(ClimateControlData.KEY_HEATED_MIRRORS_ENABLE);\n    }\n\n    /**\n     * @param {Boolean} enable - True if the climate module is on, false if the climate module is off\n     * @return {ClimateControlData}\n     */\n    setClimateEnable (enable) {\n        this.setParameter(ClimateControlData.KEY_CLIMATE_ENABLE, enable);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getClimateEnable () {\n        return this.getParameter(ClimateControlData.KEY_CLIMATE_ENABLE);\n    }\n}\n\nClimateControlData.KEY_FAN_SPEED = 'fanSpeed';\nClimateControlData.KEY_CURRENT_TEMPERATURE = 'currentTemperature';\nClimateControlData.KEY_DESIRED_TEMPERATURE = 'desiredTemperature';\nClimateControlData.KEY_AC_ENABLE = 'acEnable';\nClimateControlData.KEY_CIRCULATE_AIR_ENABLE = 'circulateAirEnable';\nClimateControlData.KEY_AUTO_MODE_ENABLE = 'autoModeEnable';\nClimateControlData.KEY_DEFROST_ZONE = 'defrostZone';\nClimateControlData.KEY_DUAL_MODE_ENABLE = 'dualModeEnable';\nClimateControlData.KEY_AC_MAX_ENABLE = 'acMaxEnable';\nClimateControlData.KEY_VENTILATION_MODE = 'ventilationMode';\nClimateControlData.KEY_HEATED_STEERING_WHEEL_ENABLE = 'heatedSteeringWheelEnable';\nClimateControlData.KEY_HEATED_WINDSHIELD_ENABLE = 'heatedWindshieldEnable';\nClimateControlData.KEY_HEATED_REAR_WINDOW_ENABLE = 'heatedRearWindowEnable';\nClimateControlData.KEY_HEATED_MIRRORS_ENABLE = 'heatedMirrorsEnable';\nClimateControlData.KEY_CLIMATE_ENABLE = 'climateEnable';\n\nexport { ClimateControlData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Defines the each Equalizer channel settings.\n */\nclass EqualizerSettings extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} id\n     * @return {EqualizerSettings}\n     */\n    setChannelId (id) {\n        this.setParameter(EqualizerSettings.KEY_CHANNEL_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getChannelId () {\n        return this.getParameter(EqualizerSettings.KEY_CHANNEL_ID);\n    }\n\n    /**\n     * @param {String} name - read-only channel / frequency name (e.i. \"Treble, Midrange, Bass\" or \"125 Hz\")\n     * @return {EqualizerSettings}\n     */\n    setChannelName (name) {\n        this.setParameter(EqualizerSettings.KEY_CHANNEL_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getChannelName () {\n        return this.getParameter(EqualizerSettings.KEY_CHANNEL_NAME);\n    }\n\n    /**\n     * @param {Number} setting - Reflects the setting, from 0%-100%.\n     * @return {EqualizerSettings}\n     */\n    setChannelSetting (setting) {\n        this.setParameter(EqualizerSettings.KEY_CHANNEL_SETTING, setting);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getChannelSetting () {\n        return this.getParameter(EqualizerSettings.KEY_CHANNEL_SETTING);\n    }\n}\n\nEqualizerSettings.KEY_CHANNEL_ID = 'channelId';\nEqualizerSettings.KEY_CHANNEL_NAME = 'channelName';\nEqualizerSettings.KEY_CHANNEL_SETTING = 'channelSetting';\n\nexport { EqualizerSettings };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { PrimaryAudioSource } from '../enums/PrimaryAudioSource.js';\nimport { EqualizerSettings } from './EqualizerSettings.js';\n\nclass AudioControlData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {PrimaryAudioSource} source - In a getter response or a notification, it is the current primary audio\n     *                                      source of the system. In a setter request, it is the target audio source\n     *                                      that the system shall switch to. If the value is MOBILE_APP, the system\n     *                                      shall switch to the mobile media app that issues the setter RPC.\n     * @return {AudioControlData}\n     */\n    setSource (source) {\n        this.validateType(PrimaryAudioSource, source);\n        this.setParameter(AudioControlData.KEY_SOURCE, source);\n        return this;\n    }\n\n    /**\n     * @return {PrimaryAudioSource}\n     */\n    getSource () {\n        return this.getObject(PrimaryAudioSource, AudioControlData.KEY_SOURCE);\n    }\n\n    /**\n     * @param {Boolean} context - This parameter shall not be present in any getter responses or notifications. This\n     *                            parameter is optional in a setter request. The default value is false if it is not\n     *                            included. If it is false, the system not only changes the audio source but also brings\n     *                            the default application or system UI associated with the audio source to foreground.\n     *                            If it is true, the system only changes the audio source, but keeps the current\n     *                            application in foreground.\n     * @return {AudioControlData}\n     */\n    setKeepContext (context) {\n        this.setParameter(AudioControlData.KEY_KEEP_CONTEXT, context);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getKeepContext () {\n        return this.getParameter(AudioControlData.KEY_KEEP_CONTEXT);\n    }\n\n    /**\n     * @param {Number} volume - Reflects the volume of audio, from 0%-100%.\n     * @return {AudioControlData}\n     */\n    setVolume (volume) {\n        this.setParameter(AudioControlData.KEY_VOLUME, volume);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getVolume () {\n        return this.getParameter(AudioControlData.KEY_VOLUME);\n    }\n\n    /**\n     * @param {EqualizerSettings[]} settings - Defines the list of supported channels (band) and their current/desired\n     *                                         settings on HMI\n     * @return {AudioControlData}\n     */\n    setEqualizerSettings (settings) {\n        this.validateType(EqualizerSettings, settings, true);\n        this.setParameter(AudioControlData.KEY_EQUALIZER_SETTINGS, settings);\n        return this;\n    }\n\n    /**\n     * @return {EqualizerSettings[]}\n     */\n    getEqualizerSettings () {\n        return this.getObject(EqualizerSettings, AudioControlData.KEY_EQUALIZER_SETTINGS);\n    }\n}\n\nAudioControlData.KEY_SOURCE = 'source';\nAudioControlData.KEY_KEEP_CONTEXT = 'keepContext';\nAudioControlData.KEY_VOLUME = 'volume';\nAudioControlData.KEY_EQUALIZER_SETTINGS = 'equalizerSettings';\n\nexport { AudioControlData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * List possible cushions of a multi-contour massage seat.\n * @typedef {Enum} MassageCushion\n * @property {Object} _MAP\n */\nclass MassageCushion extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TOP_LUMBAR () {\n        return MassageCushion._MAP.TOP_LUMBAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MIDDLE_LUMBAR () {\n        return MassageCushion._MAP.MIDDLE_LUMBAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BOTTOM_LUMBAR () {\n        return MassageCushion._MAP.BOTTOM_LUMBAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BACK_BOLSTERS () {\n        return MassageCushion._MAP.BACK_BOLSTERS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEAT_BOLSTERS () {\n        return MassageCushion._MAP.SEAT_BOLSTERS;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MassageCushion._valueForKey(key, MassageCushion._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MassageCushion._keyForValue(value, MassageCushion._MAP);\n    }\n}\n\nMassageCushion._MAP = Object.freeze({\n    'TOP_LUMBAR': 'TOP_LUMBAR',\n    'MIDDLE_LUMBAR': 'MIDDLE_LUMBAR',\n    'BOTTOM_LUMBAR': 'BOTTOM_LUMBAR',\n    'BACK_BOLSTERS': 'BACK_BOLSTERS',\n    'SEAT_BOLSTERS': 'SEAT_BOLSTERS',\n});\n\nexport { MassageCushion };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { MassageCushion } from '../enums/MassageCushion.js';\n\n/**\n * The intensity or firmness of a cushion.\n */\nclass MassageCushionFirmness extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {MassageCushion} cushion - List possible cushions of a multi-contour massage seat.\n     * @return {MassageCushionFirmness}\n     */\n    setCushion (cushion) {\n        this.validateType(MassageCushion, cushion);\n        this.setParameter(MassageCushionFirmness.KEY_CUSHION, cushion);\n        return this;\n    }\n\n    /**\n     * @return {MassageCushion}\n     */\n    getCushion () {\n        return this.getObject(MassageCushion, MassageCushionFirmness.KEY_CUSHION);\n    }\n\n    /**\n     * @param {Number} firmness\n     * @return {MassageCushionFirmness}\n     */\n    setFirmness (firmness) {\n        this.setParameter(MassageCushionFirmness.KEY_FIRMNESS, firmness);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFirmness () {\n        return this.getParameter(MassageCushionFirmness.KEY_FIRMNESS);\n    }\n}\n\nMassageCushionFirmness.KEY_CUSHION = 'cushion';\nMassageCushionFirmness.KEY_FIRMNESS = 'firmness';\n\nexport { MassageCushionFirmness };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * List possible seats that is a remote controllable seat.\n * @deprecated\n * @typedef {Enum} SupportedSeat\n * @property {Object} _MAP\n */\nclass SupportedSeat extends Enum {\n    /**\n     * @deprecated\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get DRIVER () {\n        return SupportedSeat._MAP.DRIVER;\n    }\n\n    /**\n     * @deprecated\n     * @return {String}\n     */\n    static get FRONT_PASSENGER () {\n        return SupportedSeat._MAP.FRONT_PASSENGER;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SupportedSeat._valueForKey(key, SupportedSeat._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SupportedSeat._keyForValue(value, SupportedSeat._MAP);\n    }\n}\n\nSupportedSeat._MAP = Object.freeze({\n    'DRIVER': 'DRIVER',\n    'FRONT_PASSENGER': 'FRONT_PASSENGER',\n});\n\nexport { SupportedSeat };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} SeatMemoryActionType\n * @property {Object} _MAP\n */\nclass SeatMemoryActionType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Save current seat postions and settings to seat memory.\n     * @return {String}\n     */\n    static get SAVE () {\n        return SeatMemoryActionType._MAP.SAVE;\n    }\n\n    /**\n     * Restore / apply the seat memory settings to the current seat.\n     * @return {String}\n     */\n    static get RESTORE () {\n        return SeatMemoryActionType._MAP.RESTORE;\n    }\n\n    /**\n     * No action to be performed.\n     * @return {String}\n     */\n    static get NONE () {\n        return SeatMemoryActionType._MAP.NONE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SeatMemoryActionType._valueForKey(key, SeatMemoryActionType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SeatMemoryActionType._keyForValue(value, SeatMemoryActionType._MAP);\n    }\n}\n\nSeatMemoryActionType._MAP = Object.freeze({\n    'SAVE': 'SAVE',\n    'RESTORE': 'RESTORE',\n    'NONE': 'NONE',\n});\n\nexport { SeatMemoryActionType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SeatMemoryActionType } from '../enums/SeatMemoryActionType.js';\n\nclass SeatMemoryAction extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} id\n     * @return {SeatMemoryAction}\n     */\n    setId (id) {\n        this.setParameter(SeatMemoryAction.KEY_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getId () {\n        return this.getParameter(SeatMemoryAction.KEY_ID);\n    }\n\n    /**\n     * @param {String} label\n     * @return {SeatMemoryAction}\n     */\n    setLabel (label) {\n        this.setParameter(SeatMemoryAction.KEY_LABEL, label);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getLabel () {\n        return this.getParameter(SeatMemoryAction.KEY_LABEL);\n    }\n\n    /**\n     * @param {SeatMemoryActionType} action\n     * @return {SeatMemoryAction}\n     */\n    setAction (action) {\n        this.validateType(SeatMemoryActionType, action);\n        this.setParameter(SeatMemoryAction.KEY_ACTION, action);\n        return this;\n    }\n\n    /**\n     * @return {SeatMemoryActionType}\n     */\n    getAction () {\n        return this.getObject(SeatMemoryActionType, SeatMemoryAction.KEY_ACTION);\n    }\n}\n\nSeatMemoryAction.KEY_ID = 'id';\nSeatMemoryAction.KEY_LABEL = 'label';\nSeatMemoryAction.KEY_ACTION = 'action';\n\nexport { SeatMemoryAction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * List possible zones of a multi-contour massage seat.\n * @typedef {Enum} MassageZone\n * @property {Object} _MAP\n */\nclass MassageZone extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The back of a multi-contour massage seat. or SEAT_BACK\n     * @return {String}\n     */\n    static get LUMBAR () {\n        return MassageZone._MAP.LUMBAR;\n    }\n\n    /**\n     * The bottom a multi-contour massage seat. or SEAT_BOTTOM\n     * @return {String}\n     */\n    static get SEAT_CUSHION () {\n        return MassageZone._MAP.SEAT_CUSHION;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MassageZone._valueForKey(key, MassageZone._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MassageZone._keyForValue(value, MassageZone._MAP);\n    }\n}\n\nMassageZone._MAP = Object.freeze({\n    'LUMBAR': 'LUMBAR',\n    'SEAT_CUSHION': 'SEAT_CUSHION',\n});\n\nexport { MassageZone };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * List possible modes of a massage zone.\n * @typedef {Enum} MassageMode\n * @property {Object} _MAP\n */\nclass MassageMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OFF () {\n        return MassageMode._MAP.OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LOW () {\n        return MassageMode._MAP.LOW;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HIGH () {\n        return MassageMode._MAP.HIGH;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MassageMode._valueForKey(key, MassageMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MassageMode._keyForValue(value, MassageMode._MAP);\n    }\n}\n\nMassageMode._MAP = Object.freeze({\n    'OFF': 'OFF',\n    'LOW': 'LOW',\n    'HIGH': 'HIGH',\n});\n\nexport { MassageMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { MassageZone } from '../enums/MassageZone.js';\nimport { MassageMode } from '../enums/MassageMode.js';\n\n/**\n * Specify the mode of a massage zone.\n */\nclass MassageModeData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {MassageZone} zone - List possible zones of a multi-contour massage seat.\n     * @return {MassageModeData}\n     */\n    setMassageZone (zone) {\n        this.validateType(MassageZone, zone);\n        this.setParameter(MassageModeData.KEY_MASSAGE_ZONE, zone);\n        return this;\n    }\n\n    /**\n     * @return {MassageZone}\n     */\n    getMassageZone () {\n        return this.getObject(MassageZone, MassageModeData.KEY_MASSAGE_ZONE);\n    }\n\n    /**\n     * @param {MassageMode} mode - List possible modes of a massage zone.\n     * @return {MassageModeData}\n     */\n    setMassageMode (mode) {\n        this.validateType(MassageMode, mode);\n        this.setParameter(MassageModeData.KEY_MASSAGE_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {MassageMode}\n     */\n    getMassageMode () {\n        return this.getObject(MassageMode, MassageModeData.KEY_MASSAGE_MODE);\n    }\n}\n\nMassageModeData.KEY_MASSAGE_ZONE = 'massageZone';\nMassageModeData.KEY_MASSAGE_MODE = 'massageMode';\n\nexport { MassageModeData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { MassageCushionFirmness } from './MassageCushionFirmness.js';\nimport { SupportedSeat } from '../enums/SupportedSeat.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SeatMemoryAction } from './SeatMemoryAction.js';\nimport { MassageModeData } from './MassageModeData.js';\n\n/**\n * Seat control data corresponds to \"SEAT\" ModuleType.\n */\nclass SeatControlData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {SupportedSeat} id - List possible seats that is a remote controllable seat.\n     * @return {SeatControlData}\n     */\n    setId (id) {\n        this.validateType(SupportedSeat, id);\n        this.setParameter(SeatControlData.KEY_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {SupportedSeat}\n     */\n    getId () {\n        return this.getObject(SupportedSeat, SeatControlData.KEY_ID);\n    }\n\n    /**\n     * @param {Boolean} enabled\n     * @return {SeatControlData}\n     */\n    setHeatingEnabled (enabled) {\n        this.setParameter(SeatControlData.KEY_HEATING_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatingEnabled () {\n        return this.getParameter(SeatControlData.KEY_HEATING_ENABLED);\n    }\n\n    /**\n     * @param {Boolean} enabled\n     * @return {SeatControlData}\n     */\n    setCoolingEnabled (enabled) {\n        this.setParameter(SeatControlData.KEY_COOLING_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCoolingEnabled () {\n        return this.getParameter(SeatControlData.KEY_COOLING_ENABLED);\n    }\n\n    /**\n     * @param {Number} level\n     * @return {SeatControlData}\n     */\n    setHeatingLevel (level) {\n        this.setParameter(SeatControlData.KEY_HEATING_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHeatingLevel () {\n        return this.getParameter(SeatControlData.KEY_HEATING_LEVEL);\n    }\n\n    /**\n     * @param {Number} level\n     * @return {SeatControlData}\n     */\n    setCoolingLevel (level) {\n        this.setParameter(SeatControlData.KEY_COOLING_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCoolingLevel () {\n        return this.getParameter(SeatControlData.KEY_COOLING_LEVEL);\n    }\n\n    /**\n     * @param {Number} position\n     * @return {SeatControlData}\n     */\n    setHorizontalPosition (position) {\n        this.setParameter(SeatControlData.KEY_HORIZONTAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHorizontalPosition () {\n        return this.getParameter(SeatControlData.KEY_HORIZONTAL_POSITION);\n    }\n\n    /**\n     * @param {Number} position\n     * @return {SeatControlData}\n     */\n    setVerticalPosition (position) {\n        this.setParameter(SeatControlData.KEY_VERTICAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getVerticalPosition () {\n        return this.getParameter(SeatControlData.KEY_VERTICAL_POSITION);\n    }\n\n    /**\n     * @param {Number} position\n     * @return {SeatControlData}\n     */\n    setFrontVerticalPosition (position) {\n        this.setParameter(SeatControlData.KEY_FRONT_VERTICAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFrontVerticalPosition () {\n        return this.getParameter(SeatControlData.KEY_FRONT_VERTICAL_POSITION);\n    }\n\n    /**\n     * @param {Number} position\n     * @return {SeatControlData}\n     */\n    setBackVerticalPosition (position) {\n        this.setParameter(SeatControlData.KEY_BACK_VERTICAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getBackVerticalPosition () {\n        return this.getParameter(SeatControlData.KEY_BACK_VERTICAL_POSITION);\n    }\n\n    /**\n     * @param {Number} angle\n     * @return {SeatControlData}\n     */\n    setBackTiltAngle (angle) {\n        this.setParameter(SeatControlData.KEY_BACK_TILT_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getBackTiltAngle () {\n        return this.getParameter(SeatControlData.KEY_BACK_TILT_ANGLE);\n    }\n\n    /**\n     * @param {Number} position\n     * @return {SeatControlData}\n     */\n    setHeadSupportHorizontalPosition (position) {\n        this.setParameter(SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHeadSupportHorizontalPosition () {\n        return this.getParameter(SeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION);\n    }\n\n    /**\n     * @param {Number} position\n     * @return {SeatControlData}\n     */\n    setHeadSupportVerticalPosition (position) {\n        this.setParameter(SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHeadSupportVerticalPosition () {\n        return this.getParameter(SeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION);\n    }\n\n    /**\n     * @param {Boolean} enabled\n     * @return {SeatControlData}\n     */\n    setMassageEnabled (enabled) {\n        this.setParameter(SeatControlData.KEY_MASSAGE_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMassageEnabled () {\n        return this.getParameter(SeatControlData.KEY_MASSAGE_ENABLED);\n    }\n\n    /**\n     * @param {MassageModeData[]} mode - Specify the mode of a massage zone.\n     * @return {SeatControlData}\n     */\n    setMassageMode (mode) {\n        this.validateType(MassageModeData, mode, true);\n        this.setParameter(SeatControlData.KEY_MASSAGE_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {MassageModeData[]}\n     */\n    getMassageMode () {\n        return this.getObject(MassageModeData, SeatControlData.KEY_MASSAGE_MODE);\n    }\n\n    /**\n     * @param {MassageCushionFirmness[]} firmness - The intensity or firmness of a cushion.\n     * @return {SeatControlData}\n     */\n    setMassageCushionFirmness (firmness) {\n        this.validateType(MassageCushionFirmness, firmness, true);\n        this.setParameter(SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS, firmness);\n        return this;\n    }\n\n    /**\n     * @return {MassageCushionFirmness[]}\n     */\n    getMassageCushionFirmness () {\n        return this.getObject(MassageCushionFirmness, SeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS);\n    }\n\n    /**\n     * @param {SeatMemoryAction} memory\n     * @return {SeatControlData}\n     */\n    setMemory (memory) {\n        this.validateType(SeatMemoryAction, memory);\n        this.setParameter(SeatControlData.KEY_MEMORY, memory);\n        return this;\n    }\n\n    /**\n     * @return {SeatMemoryAction}\n     */\n    getMemory () {\n        return this.getObject(SeatMemoryAction, SeatControlData.KEY_MEMORY);\n    }\n}\n\nSeatControlData.KEY_ID = 'id';\nSeatControlData.KEY_HEATING_ENABLED = 'heatingEnabled';\nSeatControlData.KEY_COOLING_ENABLED = 'coolingEnabled';\nSeatControlData.KEY_HEATING_LEVEL = 'heatingLevel';\nSeatControlData.KEY_COOLING_LEVEL = 'coolingLevel';\nSeatControlData.KEY_HORIZONTAL_POSITION = 'horizontalPosition';\nSeatControlData.KEY_VERTICAL_POSITION = 'verticalPosition';\nSeatControlData.KEY_FRONT_VERTICAL_POSITION = 'frontVerticalPosition';\nSeatControlData.KEY_BACK_VERTICAL_POSITION = 'backVerticalPosition';\nSeatControlData.KEY_BACK_TILT_ANGLE = 'backTiltAngle';\nSeatControlData.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION = 'headSupportHorizontalPosition';\nSeatControlData.KEY_HEAD_SUPPORT_VERTICAL_POSITION = 'headSupportVerticalPosition';\nSeatControlData.KEY_MASSAGE_ENABLED = 'massageEnabled';\nSeatControlData.KEY_MASSAGE_MODE = 'massageMode';\nSeatControlData.KEY_MASSAGE_CUSHION_FIRMNESS = 'massageCushionFirmness';\nSeatControlData.KEY_MEMORY = 'memory';\n\nexport { SeatControlData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} LightStatus\n * @property {Object} _MAP\n */\nclass LightStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ON () {\n        return LightStatus._MAP.ON;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OFF () {\n        return LightStatus._MAP.OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RAMP_UP () {\n        return LightStatus._MAP.RAMP_UP;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RAMP_DOWN () {\n        return LightStatus._MAP.RAMP_DOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UNKNOWN () {\n        return LightStatus._MAP.UNKNOWN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get INVALID () {\n        return LightStatus._MAP.INVALID;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return LightStatus._valueForKey(key, LightStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return LightStatus._keyForValue(value, LightStatus._MAP);\n    }\n}\n\nLightStatus._MAP = Object.freeze({\n    'ON': 'ON',\n    'OFF': 'OFF',\n    'RAMP_UP': 'RAMP_UP',\n    'RAMP_DOWN': 'RAMP_DOWN',\n    'UNKNOWN': 'UNKNOWN',\n    'INVALID': 'INVALID',\n});\n\nexport { LightStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} LightName\n * @property {Object} _MAP\n */\nclass LightName extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_LEFT_HIGH_BEAM () {\n        return LightName._MAP.FRONT_LEFT_HIGH_BEAM;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_RIGHT_HIGH_BEAM () {\n        return LightName._MAP.FRONT_RIGHT_HIGH_BEAM;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_LEFT_LOW_BEAM () {\n        return LightName._MAP.FRONT_LEFT_LOW_BEAM;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_RIGHT_LOW_BEAM () {\n        return LightName._MAP.FRONT_RIGHT_LOW_BEAM;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_LEFT_PARKING_LIGHT () {\n        return LightName._MAP.FRONT_LEFT_PARKING_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_RIGHT_PARKING_LIGHT () {\n        return LightName._MAP.FRONT_RIGHT_PARKING_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_LEFT_FOG_LIGHT () {\n        return LightName._MAP.FRONT_LEFT_FOG_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_RIGHT_FOG_LIGHT () {\n        return LightName._MAP.FRONT_RIGHT_FOG_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_LEFT_DAYTIME_RUNNING_LIGHT () {\n        return LightName._MAP.FRONT_LEFT_DAYTIME_RUNNING_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_RIGHT_DAYTIME_RUNNING_LIGHT () {\n        return LightName._MAP.FRONT_RIGHT_DAYTIME_RUNNING_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_LEFT_TURN_LIGHT () {\n        return LightName._MAP.FRONT_LEFT_TURN_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get FRONT_RIGHT_TURN_LIGHT () {\n        return LightName._MAP.FRONT_RIGHT_TURN_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_LEFT_FOG_LIGHT () {\n        return LightName._MAP.REAR_LEFT_FOG_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_RIGHT_FOG_LIGHT () {\n        return LightName._MAP.REAR_RIGHT_FOG_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_LEFT_TAIL_LIGHT () {\n        return LightName._MAP.REAR_LEFT_TAIL_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_RIGHT_TAIL_LIGHT () {\n        return LightName._MAP.REAR_RIGHT_TAIL_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_LEFT_BRAKE_LIGHT () {\n        return LightName._MAP.REAR_LEFT_BRAKE_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_RIGHT_BRAKE_LIGHT () {\n        return LightName._MAP.REAR_RIGHT_BRAKE_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_LEFT_TURN_LIGHT () {\n        return LightName._MAP.REAR_LEFT_TURN_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_RIGHT_TURN_LIGHT () {\n        return LightName._MAP.REAR_RIGHT_TURN_LIGHT;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_REGISTRATION_PLATE_LIGHT () {\n        return LightName._MAP.REAR_REGISTRATION_PLATE_LIGHT;\n    }\n\n    /**\n     * Include all high beam lights: front_left and front_right.\n     * @return {Number}\n     */\n    static get HIGH_BEAMS () {\n        return LightName._MAP.HIGH_BEAMS;\n    }\n\n    /**\n     * Include all low beam lights: front_left and front_right.\n     * @return {Number}\n     */\n    static get LOW_BEAMS () {\n        return LightName._MAP.LOW_BEAMS;\n    }\n\n    /**\n     * Include all fog lights: front_left, front_right, rear_left and rear_right.\n     * @return {Number}\n     */\n    static get FOG_LIGHTS () {\n        return LightName._MAP.FOG_LIGHTS;\n    }\n\n    /**\n     * Include all daytime running lights: front_left and front_right.\n     * @return {Number}\n     */\n    static get RUNNING_LIGHTS () {\n        return LightName._MAP.RUNNING_LIGHTS;\n    }\n\n    /**\n     * Include all parking lights: front_left and front_right.\n     * @return {Number}\n     */\n    static get PARKING_LIGHTS () {\n        return LightName._MAP.PARKING_LIGHTS;\n    }\n\n    /**\n     * Include all brake lights: rear_left and rear_right.\n     * @return {Number}\n     */\n    static get BRAKE_LIGHTS () {\n        return LightName._MAP.BRAKE_LIGHTS;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get REAR_REVERSING_LIGHTS () {\n        return LightName._MAP.REAR_REVERSING_LIGHTS;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get SIDE_MARKER_LIGHTS () {\n        return LightName._MAP.SIDE_MARKER_LIGHTS;\n    }\n\n    /**\n     * Include all left turn signal lights: front_left, rear_left, left_side and mirror_mounted.\n     * @return {Number}\n     */\n    static get LEFT_TURN_LIGHTS () {\n        return LightName._MAP.LEFT_TURN_LIGHTS;\n    }\n\n    /**\n     * Include all right turn signal lights: front_right, rear_right, right_side and mirror_mounted.\n     * @return {Number}\n     */\n    static get RIGHT_TURN_LIGHTS () {\n        return LightName._MAP.RIGHT_TURN_LIGHTS;\n    }\n\n    /**\n     * Include all hazard lights: front_left, front_right, rear_left and rear_right.\n     * @return {Number}\n     */\n    static get HAZARD_LIGHTS () {\n        return LightName._MAP.HAZARD_LIGHTS;\n    }\n\n    /**\n     * Cargo lamps illuminate the cargo area.\n     * @return {Number}\n     */\n    static get REAR_CARGO_LIGHTS () {\n        return LightName._MAP.REAR_CARGO_LIGHTS;\n    }\n\n    /**\n     * Truck bed lamps light up the bed of the truck.\n     * @return {Number}\n     */\n    static get REAR_TRUCK_BED_LIGHTS () {\n        return LightName._MAP.REAR_TRUCK_BED_LIGHTS;\n    }\n\n    /**\n     * Trailer lights are lamps mounted on a trailer hitch.\n     * @return {Number}\n     */\n    static get REAR_TRAILER_LIGHTS () {\n        return LightName._MAP.REAR_TRAILER_LIGHTS;\n    }\n\n    /**\n     * It is the spotlights mounted on the left side of a vehicle.\n     * @return {Number}\n     */\n    static get LEFT_SPOT_LIGHTS () {\n        return LightName._MAP.LEFT_SPOT_LIGHTS;\n    }\n\n    /**\n     * It is the spotlights mounted on the right side of a vehicle.\n     * @return {Number}\n     */\n    static get RIGHT_SPOT_LIGHTS () {\n        return LightName._MAP.RIGHT_SPOT_LIGHTS;\n    }\n\n    /**\n     * Puddle lamps illuminate the ground beside the door as the customer is opening or approaching the door.\n     * @return {Number}\n     */\n    static get LEFT_PUDDLE_LIGHTS () {\n        return LightName._MAP.LEFT_PUDDLE_LIGHTS;\n    }\n\n    /**\n     * Puddle lamps illuminate the ground beside the door as the customer is opening or approaching the door.\n     * @return {Number}\n     */\n    static get RIGHT_PUDDLE_LIGHTS () {\n        return LightName._MAP.RIGHT_PUDDLE_LIGHTS;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get AMBIENT_LIGHTS () {\n        return LightName._MAP.AMBIENT_LIGHTS;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get OVERHEAD_LIGHTS () {\n        return LightName._MAP.OVERHEAD_LIGHTS;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get READING_LIGHTS () {\n        return LightName._MAP.READING_LIGHTS;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get TRUNK_LIGHTS () {\n        return LightName._MAP.TRUNK_LIGHTS;\n    }\n\n    /**\n     * Include exterior lights located in front of the vehicle. For example, fog lights and low beams.\n     * @return {Number}\n     */\n    static get EXTERIOR_FRONT_LIGHTS () {\n        return LightName._MAP.EXTERIOR_FRONT_LIGHTS;\n    }\n\n    /**\n     * Include exterior lights located at the back of the vehicle. For example, license plate lights, reverse lights,\n     * cargo lights, bed lights and trailer assist lights.\n     * @return {Number}\n     */\n    static get EXTERIOR_REAR_LIGHTS () {\n        return LightName._MAP.EXTERIOR_REAR_LIGHTS;\n    }\n\n    /**\n     * Include exterior lights located at the left side of the vehicle. For example, left puddle lights and spot\n     * lights.\n     * @return {Number}\n     */\n    static get EXTERIOR_LEFT_LIGHTS () {\n        return LightName._MAP.EXTERIOR_LEFT_LIGHTS;\n    }\n\n    /**\n     * Include exterior lights located at the right side of the vehicle. For example, right puddle lights and spot\n     * lights.\n     * @return {Number}\n     */\n    static get EXTERIOR_RIGHT_LIGHTS () {\n        return LightName._MAP.EXTERIOR_RIGHT_LIGHTS;\n    }\n\n    /**\n     * Include all exterior lights around the vehicle.\n     * @return {Number}\n     */\n    static get EXTERIOR_ALL_LIGHTS () {\n        return LightName._MAP.EXTERIOR_ALL_LIGHTS;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return LightName._valueForKey(key, LightName._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return LightName._keyForValue(value, LightName._MAP);\n    }\n}\n\nLightName._MAP = Object.freeze({\n    'FRONT_LEFT_HIGH_BEAM': 0,\n    'FRONT_RIGHT_HIGH_BEAM': 1,\n    'FRONT_LEFT_LOW_BEAM': 2,\n    'FRONT_RIGHT_LOW_BEAM': 3,\n    'FRONT_LEFT_PARKING_LIGHT': 4,\n    'FRONT_RIGHT_PARKING_LIGHT': 5,\n    'FRONT_LEFT_FOG_LIGHT': 6,\n    'FRONT_RIGHT_FOG_LIGHT': 7,\n    'FRONT_LEFT_DAYTIME_RUNNING_LIGHT': 8,\n    'FRONT_RIGHT_DAYTIME_RUNNING_LIGHT': 9,\n    'FRONT_LEFT_TURN_LIGHT': 10,\n    'FRONT_RIGHT_TURN_LIGHT': 11,\n    'REAR_LEFT_FOG_LIGHT': 12,\n    'REAR_RIGHT_FOG_LIGHT': 13,\n    'REAR_LEFT_TAIL_LIGHT': 14,\n    'REAR_RIGHT_TAIL_LIGHT': 15,\n    'REAR_LEFT_BRAKE_LIGHT': 16,\n    'REAR_RIGHT_BRAKE_LIGHT': 17,\n    'REAR_LEFT_TURN_LIGHT': 18,\n    'REAR_RIGHT_TURN_LIGHT': 19,\n    'REAR_REGISTRATION_PLATE_LIGHT': 20,\n    'HIGH_BEAMS': 501,\n    'LOW_BEAMS': 502,\n    'FOG_LIGHTS': 503,\n    'RUNNING_LIGHTS': 504,\n    'PARKING_LIGHTS': 505,\n    'BRAKE_LIGHTS': 506,\n    'REAR_REVERSING_LIGHTS': 507,\n    'SIDE_MARKER_LIGHTS': 508,\n    'LEFT_TURN_LIGHTS': 509,\n    'RIGHT_TURN_LIGHTS': 510,\n    'HAZARD_LIGHTS': 511,\n    'REAR_CARGO_LIGHTS': 512,\n    'REAR_TRUCK_BED_LIGHTS': 513,\n    'REAR_TRAILER_LIGHTS': 514,\n    'LEFT_SPOT_LIGHTS': 515,\n    'RIGHT_SPOT_LIGHTS': 516,\n    'LEFT_PUDDLE_LIGHTS': 517,\n    'RIGHT_PUDDLE_LIGHTS': 518,\n    'AMBIENT_LIGHTS': 801,\n    'OVERHEAD_LIGHTS': 802,\n    'READING_LIGHTS': 803,\n    'TRUNK_LIGHTS': 804,\n    'EXTERIOR_FRONT_LIGHTS': 901,\n    'EXTERIOR_REAR_LIGHTS': 902,\n    'EXTERIOR_LEFT_LIGHTS': 903,\n    'EXTERIOR_RIGHT_LIGHTS': 904,\n    'EXTERIOR_ALL_LIGHTS': 905,\n});\n\nexport { LightName };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { LightStatus } from '../enums/LightStatus.js';\nimport { LightName } from '../enums/LightName.js';\nimport { RGBColor } from './RGBColor.js';\n\nclass LightState extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {LightName} id - The name of a light or a group of lights.\n     * @return {LightState}\n     */\n    setId (id) {\n        this.validateType(LightName, id);\n        this.setParameter(LightState.KEY_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {LightName}\n     */\n    getId () {\n        return this.getObject(LightName, LightState.KEY_ID);\n    }\n\n    /**\n     * @param {LightStatus} status\n     * @return {LightState}\n     */\n    setStatus (status) {\n        this.validateType(LightStatus, status);\n        this.setParameter(LightState.KEY_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {LightStatus}\n     */\n    getStatus () {\n        return this.getObject(LightStatus, LightState.KEY_STATUS);\n    }\n\n    /**\n     * @param {Number} density\n     * @return {LightState}\n     */\n    setDensity (density) {\n        this.setParameter(LightState.KEY_DENSITY, density);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDensity () {\n        return this.getParameter(LightState.KEY_DENSITY);\n    }\n\n    /**\n     * @param {RGBColor} color\n     * @return {LightState}\n     */\n    setColor (color) {\n        this.validateType(RGBColor, color);\n        this.setParameter(LightState.KEY_COLOR, color);\n        return this;\n    }\n\n    /**\n     * @return {RGBColor}\n     */\n    getColor () {\n        return this.getObject(RGBColor, LightState.KEY_COLOR);\n    }\n}\n\nLightState.KEY_ID = 'id';\nLightState.KEY_STATUS = 'status';\nLightState.KEY_DENSITY = 'density';\nLightState.KEY_COLOR = 'color';\n\nexport { LightState };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { LightState } from './LightState.js';\n\nclass LightControlData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {LightState[]} state - An array of LightNames and their current or desired status. No change to the status\n     *                               of the LightNames that are not listed in the array.\n     * @return {LightControlData}\n     */\n    setLightState (state) {\n        this.validateType(LightState, state, true);\n        this.setParameter(LightControlData.KEY_LIGHT_STATE, state);\n        return this;\n    }\n\n    /**\n     * @return {LightState[]}\n     */\n    getLightState () {\n        return this.getObject(LightState, LightControlData.KEY_LIGHT_STATE);\n    }\n}\n\nLightControlData.KEY_LIGHT_STATE = 'lightState';\n\nexport { LightControlData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { HMISettingsControlData } from './HMISettingsControlData.js';\nimport { RadioControlData } from './RadioControlData.js';\nimport { ModuleType } from '../enums/ModuleType.js';\nimport { ClimateControlData } from './ClimateControlData.js';\nimport { AudioControlData } from './AudioControlData.js';\nimport { SeatControlData } from './SeatControlData.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { LightControlData } from './LightControlData.js';\n\n/**\n * The moduleType indicates which type of data should be changed and identifies which data object exists in this\n * struct. For example, if the moduleType is CLIMATE then a \"climateControlData\" should exist\n */\nclass ModuleData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ModuleType} type\n     * @return {ModuleData}\n     */\n    setModuleType (type) {\n        this.validateType(ModuleType, type);\n        this.setParameter(ModuleData.KEY_MODULE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {ModuleType}\n     */\n    getModuleType () {\n        return this.getObject(ModuleType, ModuleData.KEY_MODULE_TYPE);\n    }\n\n    /**\n     * @param {String} id - Id of a module, published by System Capability.\n     * @return {ModuleData}\n     */\n    setModuleId (id) {\n        this.setParameter(ModuleData.KEY_MODULE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleId () {\n        return this.getParameter(ModuleData.KEY_MODULE_ID);\n    }\n\n    /**\n     * @param {RadioControlData} data\n     * @return {ModuleData}\n     */\n    setRadioControlData (data) {\n        this.validateType(RadioControlData, data);\n        this.setParameter(ModuleData.KEY_RADIO_CONTROL_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {RadioControlData}\n     */\n    getRadioControlData () {\n        return this.getObject(RadioControlData, ModuleData.KEY_RADIO_CONTROL_DATA);\n    }\n\n    /**\n     * @param {ClimateControlData} data\n     * @return {ModuleData}\n     */\n    setClimateControlData (data) {\n        this.validateType(ClimateControlData, data);\n        this.setParameter(ModuleData.KEY_CLIMATE_CONTROL_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {ClimateControlData}\n     */\n    getClimateControlData () {\n        return this.getObject(ClimateControlData, ModuleData.KEY_CLIMATE_CONTROL_DATA);\n    }\n\n    /**\n     * @param {SeatControlData} data - Seat control data corresponds to \"SEAT\" ModuleType.\n     * @return {ModuleData}\n     */\n    setSeatControlData (data) {\n        this.validateType(SeatControlData, data);\n        this.setParameter(ModuleData.KEY_SEAT_CONTROL_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {SeatControlData}\n     */\n    getSeatControlData () {\n        return this.getObject(SeatControlData, ModuleData.KEY_SEAT_CONTROL_DATA);\n    }\n\n    /**\n     * @param {AudioControlData} data\n     * @return {ModuleData}\n     */\n    setAudioControlData (data) {\n        this.validateType(AudioControlData, data);\n        this.setParameter(ModuleData.KEY_AUDIO_CONTROL_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {AudioControlData}\n     */\n    getAudioControlData () {\n        return this.getObject(AudioControlData, ModuleData.KEY_AUDIO_CONTROL_DATA);\n    }\n\n    /**\n     * @param {LightControlData} data\n     * @return {ModuleData}\n     */\n    setLightControlData (data) {\n        this.validateType(LightControlData, data);\n        this.setParameter(ModuleData.KEY_LIGHT_CONTROL_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {LightControlData}\n     */\n    getLightControlData () {\n        return this.getObject(LightControlData, ModuleData.KEY_LIGHT_CONTROL_DATA);\n    }\n\n    /**\n     * @param {HMISettingsControlData} data - Corresponds to \"HMI_SETTINGS\" ModuleType\n     * @return {ModuleData}\n     */\n    setHmiSettingsControlData (data) {\n        this.validateType(HMISettingsControlData, data);\n        this.setParameter(ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {HMISettingsControlData}\n     */\n    getHmiSettingsControlData () {\n        return this.getObject(HMISettingsControlData, ModuleData.KEY_HMI_SETTINGS_CONTROL_DATA);\n    }\n}\n\nModuleData.KEY_MODULE_TYPE = 'moduleType';\nModuleData.KEY_MODULE_ID = 'moduleId';\nModuleData.KEY_RADIO_CONTROL_DATA = 'radioControlData';\nModuleData.KEY_CLIMATE_CONTROL_DATA = 'climateControlData';\nModuleData.KEY_SEAT_CONTROL_DATA = 'seatControlData';\nModuleData.KEY_AUDIO_CONTROL_DATA = 'audioControlData';\nModuleData.KEY_LIGHT_CONTROL_DATA = 'lightControlData';\nModuleData.KEY_HMI_SETTINGS_CONTROL_DATA = 'hmiSettingsControlData';\n\nexport { ModuleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ModuleData } from '../structs/ModuleData.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass GetInteriorVehicleDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetInteriorVehicleData);\n    }\n\n    /**\n     * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which\n     *                            data object exists in this struct. For example, if the moduleType is CLIMATE then a\n     *                            \"climateControlData\" should exist\n     * @return {GetInteriorVehicleDataResponse}\n     */\n    setModuleData (data) {\n        this.validateType(ModuleData, data);\n        this.setParameter(GetInteriorVehicleDataResponse.KEY_MODULE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {ModuleData}\n     */\n    getModuleData () {\n        return this.getObject(ModuleData, GetInteriorVehicleDataResponse.KEY_MODULE_DATA);\n    }\n\n    /**\n     * @param {Boolean} subscribed - It is a conditional-mandatory parameter: must be returned in case \"subscribe\"\n     *                               parameter was present in the related request. if \"true\" - the \"moduleType\" from\n     *                               request is successfully subscribed and the head unit will send\n     *                               onInteriorVehicleData notifications for the moduleType. if \"false\" - the\n     *                               \"moduleType\" from request is either unsubscribed or failed to subscribe.\n     * @return {GetInteriorVehicleDataResponse}\n     */\n    setIsSubscribed (subscribed) {\n        this.setParameter(GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED, subscribed);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getIsSubscribed () {\n        return this.getParameter(GetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED);\n    }\n}\n\nGetInteriorVehicleDataResponse.KEY_MODULE_DATA = 'moduleData';\nGetInteriorVehicleDataResponse.KEY_IS_SUBSCRIBED = 'isSubscribed';\n\nexport { GetInteriorVehicleDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ModuleType } from '../enums/ModuleType.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass GetInteriorVehicleDataConsent extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetInteriorVehicleDataConsent);\n    }\n\n    /**\n     * @param {ModuleType} type - The module type that the app requests to control.\n     * @return {GetInteriorVehicleDataConsent}\n     */\n    setModuleType (type) {\n        this.validateType(ModuleType, type);\n        this.setParameter(GetInteriorVehicleDataConsent.KEY_MODULE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {ModuleType}\n     */\n    getModuleType () {\n        return this.getObject(ModuleType, GetInteriorVehicleDataConsent.KEY_MODULE_TYPE);\n    }\n\n    /**\n     * @param {String[]} ids - Ids of a module of same type, published by System Capability.\n     * @return {GetInteriorVehicleDataConsent}\n     */\n    setModuleIds (ids) {\n        this.setParameter(GetInteriorVehicleDataConsent.KEY_MODULE_IDS, ids);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getModuleIds () {\n        return this.getParameter(GetInteriorVehicleDataConsent.KEY_MODULE_IDS);\n    }\n}\n\nGetInteriorVehicleDataConsent.KEY_MODULE_TYPE = 'moduleType';\nGetInteriorVehicleDataConsent.KEY_MODULE_IDS = 'moduleIds';\n\nexport { GetInteriorVehicleDataConsent };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass GetInteriorVehicleDataConsentResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetInteriorVehicleDataConsent);\n    }\n\n    /**\n     * @param {Boolean[]} allowed - This array has the same size as \"moduleIds\" in the request and each element\n     *                              corresponds to one moduleId If true, SDL grants the permission for the requested\n     *                              module If false, SDL denies the permission for the requested module.\n     * @return {GetInteriorVehicleDataConsentResponse}\n     */\n    setAllowed (allowed) {\n        this.setParameter(GetInteriorVehicleDataConsentResponse.KEY_ALLOWED, allowed);\n        return this;\n    }\n\n    /**\n     * @return {Boolean[]}\n     */\n    getAllowed () {\n        return this.getParameter(GetInteriorVehicleDataConsentResponse.KEY_ALLOWED);\n    }\n}\n\nGetInteriorVehicleDataConsentResponse.KEY_ALLOWED = 'allowed';\n\nexport { GetInteriorVehicleDataConsentResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ModuleType } from '../enums/ModuleType.js';\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass ReleaseInteriorVehicleDataModule extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ReleaseInteriorVehicleDataModule);\n    }\n\n    /**\n     * @param {ModuleType} type\n     * @return {ReleaseInteriorVehicleDataModule}\n     */\n    setModuleType (type) {\n        this.validateType(ModuleType, type);\n        this.setParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {ModuleType}\n     */\n    getModuleType () {\n        return this.getObject(ModuleType, ReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE);\n    }\n\n    /**\n     * @param {String} id - Id of a module, published by System Capability.\n     * @return {ReleaseInteriorVehicleDataModule}\n     */\n    setModuleId (id) {\n        this.setParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleId () {\n        return this.getParameter(ReleaseInteriorVehicleDataModule.KEY_MODULE_ID);\n    }\n}\n\nReleaseInteriorVehicleDataModule.KEY_MODULE_TYPE = 'moduleType';\nReleaseInteriorVehicleDataModule.KEY_MODULE_ID = 'moduleId';\n\nexport { ReleaseInteriorVehicleDataModule };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass ReleaseInteriorVehicleDataModuleResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.ReleaseInteriorVehicleDataModule);\n    }\n}\n\n\nexport { ReleaseInteriorVehicleDataModuleResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { ModuleData } from '../structs/ModuleData.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass SetInteriorVehicleData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetInteriorVehicleData);\n    }\n\n    /**\n     * @param {ModuleData} data - The module data to set for the requested RC module.\n     * @return {SetInteriorVehicleData}\n     */\n    setModuleData (data) {\n        this.validateType(ModuleData, data);\n        this.setParameter(SetInteriorVehicleData.KEY_MODULE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {ModuleData}\n     */\n    getModuleData () {\n        return this.getObject(ModuleData, SetInteriorVehicleData.KEY_MODULE_DATA);\n    }\n}\n\nSetInteriorVehicleData.KEY_MODULE_DATA = 'moduleData';\n\nexport { SetInteriorVehicleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ModuleData } from '../structs/ModuleData.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * Used to set the values of one remote control module\n */\nclass SetInteriorVehicleDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetInteriorVehicleData);\n    }\n\n    /**\n     * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which\n     *                            data object exists in this struct. For example, if the moduleType is CLIMATE then a\n     *                            \"climateControlData\" should exist\n     * @return {SetInteriorVehicleDataResponse}\n     */\n    setModuleData (data) {\n        this.validateType(ModuleData, data);\n        this.setParameter(SetInteriorVehicleDataResponse.KEY_MODULE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {ModuleData}\n     */\n    getModuleData () {\n        return this.getObject(ModuleData, SetInteriorVehicleDataResponse.KEY_MODULE_DATA);\n    }\n}\n\nSetInteriorVehicleDataResponse.KEY_MODULE_DATA = 'moduleData';\n\nexport { SetInteriorVehicleDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * To subscribe in getting changes for Waypoints/destinations\n */\nclass SubscribeWayPoints extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SubscribeWayPoints);\n    }\n}\n\n\nexport { SubscribeWayPoints };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SubscribeWayPointsResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SubscribeWayPoints);\n    }\n}\n\n\nexport { SubscribeWayPointsResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Describes what kind of waypoint is requested/provided.\n * @typedef {Enum} WayPointType\n * @property {Object} _MAP\n */\nclass WayPointType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ALL () {\n        return WayPointType._MAP.ALL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DESTINATION () {\n        return WayPointType._MAP.DESTINATION;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return WayPointType._valueForKey(key, WayPointType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return WayPointType._keyForValue(value, WayPointType._MAP);\n    }\n}\n\nWayPointType._MAP = Object.freeze({\n    'ALL': 'ALL',\n    'DESTINATION': 'DESTINATION',\n});\n\nexport { WayPointType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { WayPointType } from '../enums/WayPointType.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Request for getting waypoint/destination data.\n */\nclass GetWayPoints extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetWayPoints);\n    }\n\n    /**\n     * @param {WayPointType} type - To request for either the destination only or for all waypoints including\n     *                              destination\n     * @return {GetWayPoints}\n     */\n    setWayPointType (type) {\n        this.validateType(WayPointType, type);\n        this.setParameter(GetWayPoints.KEY_WAY_POINT_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {WayPointType}\n     */\n    getWayPointType () {\n        return this.getObject(WayPointType, GetWayPoints.KEY_WAY_POINT_TYPE);\n    }\n}\n\nGetWayPoints.KEY_WAY_POINT_TYPE = 'wayPointType';\n\nexport { GetWayPoints };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass Coordinate extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} degrees - Latitude of the location.\n     * @return {Coordinate}\n     */\n    setLatitudeDegrees (degrees) {\n        this.setParameter(Coordinate.KEY_LATITUDE_DEGREES, degrees);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLatitudeDegrees () {\n        return this.getParameter(Coordinate.KEY_LATITUDE_DEGREES);\n    }\n\n    /**\n     * @param {Number} degrees - Longitude of the location.\n     * @return {Coordinate}\n     */\n    setLongitudeDegrees (degrees) {\n        this.setParameter(Coordinate.KEY_LONGITUDE_DEGREES, degrees);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLongitudeDegrees () {\n        return this.getParameter(Coordinate.KEY_LONGITUDE_DEGREES);\n    }\n}\n\nCoordinate.KEY_LATITUDE_DEGREES = 'latitudeDegrees';\nCoordinate.KEY_LONGITUDE_DEGREES = 'longitudeDegrees';\n\nexport { Coordinate };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Coordinate } from './Coordinate.js';\nimport { Image } from './Image.js';\nimport { OASISAddress } from './OASISAddress.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass LocationDetails extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Coordinate} coordinate - Latitude/Longitude of the location.\n     * @return {LocationDetails}\n     */\n    setCoordinate (coordinate) {\n        this.validateType(Coordinate, coordinate);\n        this.setParameter(LocationDetails.KEY_COORDINATE, coordinate);\n        return this;\n    }\n\n    /**\n     * @return {Coordinate}\n     */\n    getCoordinate () {\n        return this.getObject(Coordinate, LocationDetails.KEY_COORDINATE);\n    }\n\n    /**\n     * @param {String} name - Name of location.\n     * @return {LocationDetails}\n     */\n    setLocationName (name) {\n        this.setParameter(LocationDetails.KEY_LOCATION_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getLocationName () {\n        return this.getParameter(LocationDetails.KEY_LOCATION_NAME);\n    }\n\n    /**\n     * @param {String[]} lines - Location address for display purposes only\n     * @return {LocationDetails}\n     */\n    setAddressLines (lines) {\n        this.setParameter(LocationDetails.KEY_ADDRESS_LINES, lines);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getAddressLines () {\n        return this.getParameter(LocationDetails.KEY_ADDRESS_LINES);\n    }\n\n    /**\n     * @param {String} description - Description intended location / establishment (if applicable)\n     * @return {LocationDetails}\n     */\n    setLocationDescription (description) {\n        this.setParameter(LocationDetails.KEY_LOCATION_DESCRIPTION, description);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getLocationDescription () {\n        return this.getParameter(LocationDetails.KEY_LOCATION_DESCRIPTION);\n    }\n\n    /**\n     * @param {String} number - Phone number of location / establishment.\n     * @return {LocationDetails}\n     */\n    setPhoneNumber (number) {\n        this.setParameter(LocationDetails.KEY_PHONE_NUMBER, number);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPhoneNumber () {\n        return this.getParameter(LocationDetails.KEY_PHONE_NUMBER);\n    }\n\n    /**\n     * @param {Image} image - Image / icon of intended location.\n     * @return {LocationDetails}\n     */\n    setLocationImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(LocationDetails.KEY_LOCATION_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getLocationImage () {\n        return this.getObject(Image, LocationDetails.KEY_LOCATION_IMAGE);\n    }\n\n    /**\n     * @param {OASISAddress} address - Address to be used by navigation engines for search\n     * @return {LocationDetails}\n     */\n    setSearchAddress (address) {\n        this.validateType(OASISAddress, address);\n        this.setParameter(LocationDetails.KEY_SEARCH_ADDRESS, address);\n        return this;\n    }\n\n    /**\n     * @return {OASISAddress}\n     */\n    getSearchAddress () {\n        return this.getObject(OASISAddress, LocationDetails.KEY_SEARCH_ADDRESS);\n    }\n}\n\nLocationDetails.KEY_COORDINATE = 'coordinate';\nLocationDetails.KEY_LOCATION_NAME = 'locationName';\nLocationDetails.KEY_ADDRESS_LINES = 'addressLines';\nLocationDetails.KEY_LOCATION_DESCRIPTION = 'locationDescription';\nLocationDetails.KEY_PHONE_NUMBER = 'phoneNumber';\nLocationDetails.KEY_LOCATION_IMAGE = 'locationImage';\nLocationDetails.KEY_SEARCH_ADDRESS = 'searchAddress';\n\nexport { LocationDetails };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { LocationDetails } from '../structs/LocationDetails.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass GetWayPointsResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetWayPoints);\n    }\n\n    /**\n     * @param {LocationDetails[]} points - See LocationDetails\n     * @return {GetWayPointsResponse}\n     */\n    setWayPoints (points) {\n        this.validateType(LocationDetails, points, true);\n        this.setParameter(GetWayPointsResponse.KEY_WAY_POINTS, points);\n        return this;\n    }\n\n    /**\n     * @return {LocationDetails[]}\n     */\n    getWayPoints () {\n        return this.getObject(LocationDetails, GetWayPointsResponse.KEY_WAY_POINTS);\n    }\n}\n\nGetWayPointsResponse.KEY_WAY_POINTS = 'wayPoints';\n\nexport { GetWayPointsResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Request to unsubscribe from WayPoints and Destination\n */\nclass UnsubscribeWayPoints extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnsubscribeWayPoints);\n    }\n}\n\n\nexport { UnsubscribeWayPoints };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { LocationDetails } from '../structs/LocationDetails.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass UnsubscribeWayPointsResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnsubscribeWayPoints);\n    }\n\n    /**\n     * @param {LocationDetails[]} points - See LocationDetails\n     * @return {UnsubscribeWayPointsResponse}\n     */\n    setWayPoints (points) {\n        this.validateType(LocationDetails, points, true);\n        this.setParameter(UnsubscribeWayPointsResponse.KEY_WAY_POINTS, points);\n        return this;\n    }\n\n    /**\n     * @return {LocationDetails[]}\n     */\n    getWayPoints () {\n        return this.getObject(LocationDetails, UnsubscribeWayPointsResponse.KEY_WAY_POINTS);\n    }\n}\n\nUnsubscribeWayPointsResponse.KEY_WAY_POINTS = 'wayPoints';\n\nexport { UnsubscribeWayPointsResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumerations of all available system capability types\n * @typedef {Enum} SystemCapabilityType\n * @property {Object} _MAP\n */\nclass SystemCapabilityType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAVIGATION () {\n        return SystemCapabilityType._MAP.NAVIGATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PHONE_CALL () {\n        return SystemCapabilityType._MAP.PHONE_CALL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VIDEO_STREAMING () {\n        return SystemCapabilityType._MAP.VIDEO_STREAMING;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REMOTE_CONTROL () {\n        return SystemCapabilityType._MAP.REMOTE_CONTROL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get APP_SERVICES () {\n        return SystemCapabilityType._MAP.APP_SERVICES;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get SEAT_LOCATION () {\n        return SystemCapabilityType._MAP.SEAT_LOCATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DISPLAYS () {\n        return SystemCapabilityType._MAP.DISPLAYS;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SystemCapabilityType._valueForKey(key, SystemCapabilityType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SystemCapabilityType._keyForValue(value, SystemCapabilityType._MAP);\n    }\n}\n\nSystemCapabilityType._MAP = Object.freeze({\n    'NAVIGATION': 'NAVIGATION',\n    'PHONE_CALL': 'PHONE_CALL',\n    'VIDEO_STREAMING': 'VIDEO_STREAMING',\n    'REMOTE_CONTROL': 'REMOTE_CONTROL',\n    'APP_SERVICES': 'APP_SERVICES',\n    'SEAT_LOCATION': 'SEAT_LOCATION',\n    'DISPLAYS': 'DISPLAYS',\n});\n\nexport { SystemCapabilityType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { SystemCapabilityType } from '../enums/SystemCapabilityType.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Request for expanded information about a supported system/HMI capability\n */\nclass GetSystemCapability extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetSystemCapability);\n    }\n\n    /**\n     * @param {SystemCapabilityType} type - The type of system capability to get more information on\n     * @return {GetSystemCapability}\n     */\n    setSystemCapabilityType (type) {\n        this.validateType(SystemCapabilityType, type);\n        this.setParameter(GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {SystemCapabilityType}\n     */\n    getSystemCapabilityType () {\n        return this.getObject(SystemCapabilityType, GetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE);\n    }\n\n    /**\n     * @param {Boolean} subscribe - Flag to subscribe to updates of the supplied service capability type. If true, the\n     *                              requester will be subscribed. If false, the requester will not be subscribed and be\n     *                              removed as a subscriber if it was previously subscribed.\n     * @return {GetSystemCapability}\n     */\n    setSubscribe (subscribe) {\n        this.setParameter(GetSystemCapability.KEY_SUBSCRIBE, subscribe);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSubscribe () {\n        return this.getParameter(GetSystemCapability.KEY_SUBSCRIBE);\n    }\n}\n\nGetSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE = 'systemCapabilityType';\nGetSystemCapability.KEY_SUBSCRIBE = 'subscribe';\n\nexport { GetSystemCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enum for each type of video streaming codec.\n * @typedef {Enum} VideoStreamingCodec\n * @property {Object} _MAP\n */\nclass VideoStreamingCodec extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * A block-oriented motion-compensation-based video compression standard. As of 2014 it is one of the most\n     * commonly used formats for the recording, compression, and distribution of video content.\n     * @return {String}\n     */\n    static get H264 () {\n        return VideoStreamingCodec._MAP.H264;\n    }\n\n    /**\n     * High Efficiency Video Coding (HEVC), also known as H.265 and MPEG-H Part 2, is a video compression standard,\n     * one of several potential successors to the widely used AVC (H.264 or MPEG-4 Part 10). In comparison to AVC,\n     * HEVC offers about double the data compression ratio at the same level of video quality, or substantially\n     * improved video quality at the same bit rate. It supports resolutions up to 8192x4320, including 8K UHD.\n     * @return {String}\n     */\n    static get H265 () {\n        return VideoStreamingCodec._MAP.H265;\n    }\n\n    /**\n     * Theora is derived from the formerly proprietary VP3 codec, released into the public domain by On2 Technologies.\n     * It is broadly comparable in design and bitrate efficiency to MPEG-4 Part 2, early versions of Windows Media\n     * Video, and RealVideo while lacking some of the features present in some of these other codecs. It is comparable\n     * in open standards philosophy to the BBC's Dirac codec.\n     * @return {String}\n     */\n    static get Theora () {\n        return VideoStreamingCodec._MAP.Theora;\n    }\n\n    /**\n     * VP8 can be multiplexed into the Matroska-based container format WebM along with Vorbis and Opus audio. The\n     * image format WebP is based on VP8's intra-frame coding. VP8's direct successor, VP9, and the emerging royalty-\n     * free internet video format AV1 from the Alliance for Open Media (AOMedia) are based on VP8.\n     * @return {String}\n     */\n    static get VP8 () {\n        return VideoStreamingCodec._MAP.VP8;\n    }\n\n    /**\n     * Similar to VP8, but VP9 is customized for video resolutions beyond high-definition video (UHD) and also enables\n     * lossless compression.\n     * @return {String}\n     */\n    static get VP9 () {\n        return VideoStreamingCodec._MAP.VP9;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VideoStreamingCodec._valueForKey(key, VideoStreamingCodec._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VideoStreamingCodec._keyForValue(value, VideoStreamingCodec._MAP);\n    }\n}\n\nVideoStreamingCodec._MAP = Object.freeze({\n    'H264': 'H264',\n    'H265': 'H265',\n    'Theora': 'Theora',\n    'VP8': 'VP8',\n    'VP9': 'VP9',\n});\n\nexport { VideoStreamingCodec };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enum for each type of video streaming protocol type.\n * @typedef {Enum} VideoStreamingProtocol\n * @property {Object} _MAP\n */\nclass VideoStreamingProtocol extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Raw stream bytes that contains no timestamp data and is the lowest supported video streaming\n     * @return {String}\n     */\n    static get RAW () {\n        return VideoStreamingProtocol._MAP.RAW;\n    }\n\n    /**\n     * RTP facilitates the transfer of real-time data. Information provided by this protocol include timestamps (for\n     * synchronization), sequence numbers (for packet loss and reordering detection) and the payload format which\n     * indicates the encoded format of the data.\n     * @return {String}\n     */\n    static get RTP () {\n        return VideoStreamingProtocol._MAP.RTP;\n    }\n\n    /**\n     * The transmission of streaming data itself is not a task of RTSP. Most RTSP servers use the Real-time Transport\n     * Protocol (RTP) in conjunction with Real-time Control Protocol (RTCP) for media stream delivery. However, some\n     * vendors implement proprietary transport protocols.\n     * @return {String}\n     */\n    static get RTSP () {\n        return VideoStreamingProtocol._MAP.RTSP;\n    }\n\n    /**\n     * Real-Time Messaging Protocol (RTMP) was initially a proprietary protocol developed by Macromedia for streaming\n     * audio, video and data over the Internet, between a Flash player and a server. Macromedia is now owned by Adobe,\n     * which has released an incomplete version of the specification of the protocol for public use.\n     * @return {String}\n     */\n    static get RTMP () {\n        return VideoStreamingProtocol._MAP.RTMP;\n    }\n\n    /**\n     * The WebM container is based on a profile of Matroska. WebM initially supported VP8 video and Vorbis audio\n     * streams. In 2013 it was updated to accommodate VP9 video and Opus audio.\n     * @return {String}\n     */\n    static get WEBM () {\n        return VideoStreamingProtocol._MAP.WEBM;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VideoStreamingProtocol._valueForKey(key, VideoStreamingProtocol._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VideoStreamingProtocol._keyForValue(value, VideoStreamingProtocol._MAP);\n    }\n}\n\nVideoStreamingProtocol._MAP = Object.freeze({\n    'RAW': 'RAW',\n    'RTP': 'RTP',\n    'RTSP': 'RTSP',\n    'RTMP': 'RTMP',\n    'WEBM': 'WEBM',\n});\n\nexport { VideoStreamingProtocol };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { VideoStreamingCodec } from '../enums/VideoStreamingCodec.js';\nimport { VideoStreamingProtocol } from '../enums/VideoStreamingProtocol.js';\n\n/**\n * Video streaming formats and their specifications.\n */\nclass VideoStreamingFormat extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {VideoStreamingProtocol} protocol - Protocol type, see VideoStreamingProtocol\n     * @return {VideoStreamingFormat}\n     */\n    setProtocol (protocol) {\n        this.validateType(VideoStreamingProtocol, protocol);\n        this.setParameter(VideoStreamingFormat.KEY_PROTOCOL, protocol);\n        return this;\n    }\n\n    /**\n     * @return {VideoStreamingProtocol}\n     */\n    getProtocol () {\n        return this.getObject(VideoStreamingProtocol, VideoStreamingFormat.KEY_PROTOCOL);\n    }\n\n    /**\n     * @param {VideoStreamingCodec} codec - Codec type, see VideoStreamingCodec\n     * @return {VideoStreamingFormat}\n     */\n    setCodec (codec) {\n        this.validateType(VideoStreamingCodec, codec);\n        this.setParameter(VideoStreamingFormat.KEY_CODEC, codec);\n        return this;\n    }\n\n    /**\n     * @return {VideoStreamingCodec}\n     */\n    getCodec () {\n        return this.getObject(VideoStreamingCodec, VideoStreamingFormat.KEY_CODEC);\n    }\n}\n\nVideoStreamingFormat.KEY_PROTOCOL = 'protocol';\nVideoStreamingFormat.KEY_CODEC = 'codec';\n\nexport { VideoStreamingFormat };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ImageResolution } from './ImageResolution.js';\nimport { VideoStreamingFormat } from './VideoStreamingFormat.js';\n\n/**\n * Contains information about this system's video streaming capabilities.\n */\nclass VideoStreamingCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ImageResolution} resolution - The preferred resolution of a video stream for decoding and rendering on\n     *                                       HMI.\n     * @return {VideoStreamingCapability}\n     */\n    setPreferredResolution (resolution) {\n        this.validateType(ImageResolution, resolution);\n        this.setParameter(VideoStreamingCapability.KEY_PREFERRED_RESOLUTION, resolution);\n        return this;\n    }\n\n    /**\n     * @return {ImageResolution}\n     */\n    getPreferredResolution () {\n        return this.getObject(ImageResolution, VideoStreamingCapability.KEY_PREFERRED_RESOLUTION);\n    }\n\n    /**\n     * @param {Number} bitrate - The maximum bitrate of video stream that is supported, in kbps.\n     * @return {VideoStreamingCapability}\n     */\n    setMaxBitrate (bitrate) {\n        this.setParameter(VideoStreamingCapability.KEY_MAX_BITRATE, bitrate);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaxBitrate () {\n        return this.getParameter(VideoStreamingCapability.KEY_MAX_BITRATE);\n    }\n\n    /**\n     * @param {VideoStreamingFormat[]} formats - Detailed information on each format supported by this system, in its\n     *                                           preferred order (i.e. the first element in the array is most preferable\n     *                                           to the system). Each object will contain a VideoStreamingFormat that\n     *                                           describes what can be expected.\n     * @return {VideoStreamingCapability}\n     */\n    setSupportedFormats (formats) {\n        this.validateType(VideoStreamingFormat, formats, true);\n        this.setParameter(VideoStreamingCapability.KEY_SUPPORTED_FORMATS, formats);\n        return this;\n    }\n\n    /**\n     * @return {VideoStreamingFormat[]}\n     */\n    getSupportedFormats () {\n        return this.getObject(VideoStreamingFormat, VideoStreamingCapability.KEY_SUPPORTED_FORMATS);\n    }\n\n    /**\n     * @param {Boolean} supported - True if the system can utilize the haptic spatial data from the source being\n     *                              streamed. If not included, it can be assumed the module doesn't support haptic\n     *                              spatial data'.\n     * @return {VideoStreamingCapability}\n     */\n    setHapticSpatialDataSupported (supported) {\n        this.setParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHapticSpatialDataSupported () {\n        return this.getParameter(VideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED);\n    }\n\n    /**\n     * @param {Number} size - The diagonal screen size in inches.\n     * @return {VideoStreamingCapability}\n     */\n    setDiagonalScreenSize (size) {\n        this.setParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE, size);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getDiagonalScreenSize () {\n        return this.getParameter(VideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE);\n    }\n\n    /**\n     * @param {Number} inch - PPI is the diagonal resolution in pixels divided by the diagonal screen size in inches.\n     * @return {VideoStreamingCapability}\n     */\n    setPixelPerInch (inch) {\n        this.setParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH, inch);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPixelPerInch () {\n        return this.getParameter(VideoStreamingCapability.KEY_PIXEL_PER_INCH);\n    }\n\n    /**\n     * @param {Number} scale - The scaling factor the app should use to change the size of the projecting view.\n     * @return {VideoStreamingCapability}\n     */\n    setScale (scale) {\n        this.setParameter(VideoStreamingCapability.KEY_SCALE, scale);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getScale () {\n        return this.getParameter(VideoStreamingCapability.KEY_SCALE);\n    }\n}\n\nVideoStreamingCapability.KEY_PREFERRED_RESOLUTION = 'preferredResolution';\nVideoStreamingCapability.KEY_MAX_BITRATE = 'maxBitrate';\nVideoStreamingCapability.KEY_SUPPORTED_FORMATS = 'supportedFormats';\nVideoStreamingCapability.KEY_HAPTIC_SPATIAL_DATA_SUPPORTED = 'hapticSpatialDataSupported';\nVideoStreamingCapability.KEY_DIAGONAL_SCREEN_SIZE = 'diagonalScreenSize';\nVideoStreamingCapability.KEY_PIXEL_PER_INCH = 'pixelPerInch';\nVideoStreamingCapability.KEY_SCALE = 'scale';\n\nexport { VideoStreamingCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Extended capabilities of the module's phone feature\n */\nclass PhoneCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} enabled - If the module has the ability to perform dial number\n     * @return {PhoneCapability}\n     */\n    setDialNumberEnabled (enabled) {\n        this.setParameter(PhoneCapability.KEY_DIAL_NUMBER_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDialNumberEnabled () {\n        return this.getParameter(PhoneCapability.KEY_DIAL_NUMBER_ENABLED);\n    }\n}\n\nPhoneCapability.KEY_DIAL_NUMBER_ENABLED = 'dialNumberEnabled';\n\nexport { PhoneCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { WindowType } from '../enums/WindowType.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass WindowTypeCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {WindowType} type\n     * @return {WindowTypeCapabilities}\n     */\n    setType (type) {\n        this.validateType(WindowType, type);\n        this.setParameter(WindowTypeCapabilities.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {WindowType}\n     */\n    getType () {\n        return this.getObject(WindowType, WindowTypeCapabilities.KEY_TYPE);\n    }\n\n    /**\n     * @param {Number} windows\n     * @return {WindowTypeCapabilities}\n     */\n    setMaximumNumberOfWindows (windows) {\n        this.setParameter(WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS, windows);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaximumNumberOfWindows () {\n        return this.getParameter(WindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS);\n    }\n}\n\nWindowTypeCapabilities.KEY_TYPE = 'type';\nWindowTypeCapabilities.KEY_MAXIMUM_NUMBER_OF_WINDOWS = 'maximumNumberOfWindows';\n\nexport { WindowTypeCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ImageField } from './ImageField.js';\nimport { TextField } from './TextField.js';\nimport { ImageType } from '../enums/ImageType.js';\nimport { MenuLayout } from '../enums/MenuLayout.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ButtonCapabilities } from './ButtonCapabilities.js';\nimport { SoftButtonCapabilities } from './SoftButtonCapabilities.js';\n\nclass WindowCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} id - The specified ID of the window. This ID is either one used when sending the CreateWindow\n     *                      request, or one of the predefined window ID values from the enum PredefinedWindows. If\n     *                      ommited, value is assumed to be the main window on the main display.\n     * @return {WindowCapability}\n     */\n    setWindowID (id) {\n        this.setParameter(WindowCapability.KEY_WINDOW_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindowID () {\n        return this.getParameter(WindowCapability.KEY_WINDOW_ID);\n    }\n\n    /**\n     * @param {TextField[]} fields - A set of all fields that support text data. See TextField\n     * @return {WindowCapability}\n     */\n    setTextFields (fields) {\n        this.validateType(TextField, fields, true);\n        this.setParameter(WindowCapability.KEY_TEXT_FIELDS, fields);\n        return this;\n    }\n\n    /**\n     * @return {TextField[]}\n     */\n    getTextFields () {\n        return this.getObject(TextField, WindowCapability.KEY_TEXT_FIELDS);\n    }\n\n    /**\n     * @param {ImageField[]} fields - A set of all fields that support images. See ImageField\n     * @return {WindowCapability}\n     */\n    setImageFields (fields) {\n        this.validateType(ImageField, fields, true);\n        this.setParameter(WindowCapability.KEY_IMAGE_FIELDS, fields);\n        return this;\n    }\n\n    /**\n     * @return {ImageField[]}\n     */\n    getImageFields () {\n        return this.getObject(ImageField, WindowCapability.KEY_IMAGE_FIELDS);\n    }\n\n    /**\n     * @param {ImageType[]} supported - Provides information about image types supported by the system.\n     * @return {WindowCapability}\n     */\n    setImageTypeSupported (supported) {\n        this.validateType(ImageType, supported, true);\n        this.setParameter(WindowCapability.KEY_IMAGE_TYPE_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {ImageType[]}\n     */\n    getImageTypeSupported () {\n        return this.getObject(ImageType, WindowCapability.KEY_IMAGE_TYPE_SUPPORTED);\n    }\n\n    /**\n     * @param {String[]} available - A set of all window templates available on the head unit.\n     * @return {WindowCapability}\n     */\n    setTemplatesAvailable (available) {\n        this.setParameter(WindowCapability.KEY_TEMPLATES_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getTemplatesAvailable () {\n        return this.getParameter(WindowCapability.KEY_TEMPLATES_AVAILABLE);\n    }\n\n    /**\n     * @param {Number} available - The number of on-window custom presets available (if any); otherwise omitted.\n     * @return {WindowCapability}\n     */\n    setNumCustomPresetsAvailable (available) {\n        this.setParameter(WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getNumCustomPresetsAvailable () {\n        return this.getParameter(WindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE);\n    }\n\n    /**\n     * @param {ButtonCapabilities[]} capabilities - The number of buttons and the capabilities of each on-window button.\n     * @return {WindowCapability}\n     */\n    setButtonCapabilities (capabilities) {\n        this.validateType(ButtonCapabilities, capabilities, true);\n        this.setParameter(WindowCapability.KEY_BUTTON_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {ButtonCapabilities[]}\n     */\n    getButtonCapabilities () {\n        return this.getObject(ButtonCapabilities, WindowCapability.KEY_BUTTON_CAPABILITIES);\n    }\n\n    /**\n     * @param {SoftButtonCapabilities[]} capabilities - The number of soft buttons available on-window and the\n     *                                                  capabilities for each button.\n     * @return {WindowCapability}\n     */\n    setSoftButtonCapabilities (capabilities) {\n        this.validateType(SoftButtonCapabilities, capabilities, true);\n        this.setParameter(WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {SoftButtonCapabilities[]}\n     */\n    getSoftButtonCapabilities () {\n        return this.getObject(SoftButtonCapabilities, WindowCapability.KEY_SOFT_BUTTON_CAPABILITIES);\n    }\n\n    /**\n     * @param {MenuLayout[]} available - An array of available menu layouts. If this parameter is not provided, only the\n     *                                   `LIST` layout is assumed to be available\n     * @return {WindowCapability}\n     */\n    setMenuLayoutsAvailable (available) {\n        this.validateType(MenuLayout, available, true);\n        this.setParameter(WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {MenuLayout[]}\n     */\n    getMenuLayoutsAvailable () {\n        return this.getObject(MenuLayout, WindowCapability.KEY_MENU_LAYOUTS_AVAILABLE);\n    }\n}\n\nWindowCapability.KEY_WINDOW_ID = 'windowID';\nWindowCapability.KEY_TEXT_FIELDS = 'textFields';\nWindowCapability.KEY_IMAGE_FIELDS = 'imageFields';\nWindowCapability.KEY_IMAGE_TYPE_SUPPORTED = 'imageTypeSupported';\nWindowCapability.KEY_TEMPLATES_AVAILABLE = 'templatesAvailable';\nWindowCapability.KEY_NUM_CUSTOM_PRESETS_AVAILABLE = 'numCustomPresetsAvailable';\nWindowCapability.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities';\nWindowCapability.KEY_SOFT_BUTTON_CAPABILITIES = 'softButtonCapabilities';\nWindowCapability.KEY_MENU_LAYOUTS_AVAILABLE = 'menuLayoutsAvailable';\n\nexport { WindowCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { WindowTypeCapabilities } from './WindowTypeCapabilities.js';\nimport { WindowCapability } from './WindowCapability.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass DisplayCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name\n     * @return {DisplayCapability}\n     */\n    setDisplayName (name) {\n        this.setParameter(DisplayCapability.KEY_DISPLAY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getDisplayName () {\n        return this.getParameter(DisplayCapability.KEY_DISPLAY_NAME);\n    }\n\n    /**\n     * @param {WindowTypeCapabilities[]} supported - Informs the application how many windows the app is allowed to\n     *                                               create per type.\n     * @return {DisplayCapability}\n     */\n    setWindowTypeSupported (supported) {\n        this.validateType(WindowTypeCapabilities, supported, true);\n        this.setParameter(DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {WindowTypeCapabilities[]}\n     */\n    getWindowTypeSupported () {\n        return this.getObject(WindowTypeCapabilities, DisplayCapability.KEY_WINDOW_TYPE_SUPPORTED);\n    }\n\n    /**\n     * @param {WindowCapability[]} capabilities - Contains a list of capabilities of all windows related to the app.\n     *                                            Once the app has registered the capabilities of all windows are\n     *                                            provided. GetSystemCapability still allows requesting window\n     *                                            capabilities of all windows. After registration, only windows with\n     *                                            capabilities changed will be included. Following cases will cause only\n     *                                            affected windows to be included: 1. App creates a new window. After\n     *                                            the window is created, a system capability notification will be sent\n     *                                            related only to the created window. 2. App sets a new layout to the\n     *                                            window. The new layout changes window capabilties. The notification\n     *                                            will reflect those changes to the single window.\n     * @return {DisplayCapability}\n     */\n    setWindowCapabilities (capabilities) {\n        this.validateType(WindowCapability, capabilities, true);\n        this.setParameter(DisplayCapability.KEY_WINDOW_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {WindowCapability[]}\n     */\n    getWindowCapabilities () {\n        return this.getObject(WindowCapability, DisplayCapability.KEY_WINDOW_CAPABILITIES);\n    }\n}\n\nDisplayCapability.KEY_DISPLAY_NAME = 'displayName';\nDisplayCapability.KEY_WINDOW_TYPE_SUPPORTED = 'windowTypeSupported';\nDisplayCapability.KEY_WINDOW_CAPABILITIES = 'windowCapabilities';\n\nexport { DisplayCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ModuleInfo } from './ModuleInfo.js';\n\nclass AudioControlCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - The short friendly name of the light control module. It should not be used to identify a\n     *                        module by mobile application.\n     * @return {AudioControlCapabilities}\n     */\n    setModuleName (name) {\n        this.setParameter(AudioControlCapabilities.KEY_MODULE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleName () {\n        return this.getParameter(AudioControlCapabilities.KEY_MODULE_NAME);\n    }\n\n    /**\n     * @param {ModuleInfo} info - Information about a RC module, including its id.\n     * @return {AudioControlCapabilities}\n     */\n    setModuleInfo (info) {\n        this.validateType(ModuleInfo, info);\n        this.setParameter(AudioControlCapabilities.KEY_MODULE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ModuleInfo}\n     */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, AudioControlCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of audio source.\n     * @return {AudioControlCapabilities}\n     */\n    setSourceAvailable (available) {\n        this.setParameter(AudioControlCapabilities.KEY_SOURCE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSourceAvailable () {\n        return this.getParameter(AudioControlCapabilities.KEY_SOURCE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the keepContext parameter.\n     * @return {AudioControlCapabilities}\n     */\n    setKeepContextAvailable (available) {\n        this.setParameter(AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getKeepContextAvailable () {\n        return this.getParameter(AudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of audio volume.\n     * @return {AudioControlCapabilities}\n     */\n    setVolumeAvailable (available) {\n        this.setParameter(AudioControlCapabilities.KEY_VOLUME_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getVolumeAvailable () {\n        return this.getParameter(AudioControlCapabilities.KEY_VOLUME_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of Equalizer Settings.\n     * @return {AudioControlCapabilities}\n     */\n    setEqualizerAvailable (available) {\n        this.setParameter(AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEqualizerAvailable () {\n        return this.getParameter(AudioControlCapabilities.KEY_EQUALIZER_AVAILABLE);\n    }\n\n    /**\n     * @param {Number} id - Must be included if equalizerAvailable=true, and assume all IDs starting from 1 to this\n     *                      value are valid\n     * @return {AudioControlCapabilities}\n     */\n    setEqualizerMaxChannelId (id) {\n        this.setParameter(AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEqualizerMaxChannelId () {\n        return this.getParameter(AudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID);\n    }\n}\n\nAudioControlCapabilities.KEY_MODULE_NAME = 'moduleName';\nAudioControlCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nAudioControlCapabilities.KEY_SOURCE_AVAILABLE = 'sourceAvailable';\nAudioControlCapabilities.KEY_KEEP_CONTEXT_AVAILABLE = 'keepContextAvailable';\nAudioControlCapabilities.KEY_VOLUME_AVAILABLE = 'volumeAvailable';\nAudioControlCapabilities.KEY_EQUALIZER_AVAILABLE = 'equalizerAvailable';\nAudioControlCapabilities.KEY_EQUALIZER_MAX_CHANNEL_ID = 'equalizerMaxChannelId';\n\nexport { AudioControlCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { LightName } from '../enums/LightName.js';\n\nclass LightCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {LightName} name\n     * @return {LightCapabilities}\n     */\n    setName (name) {\n        this.validateType(LightName, name);\n        this.setParameter(LightCapabilities.KEY_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {LightName}\n     */\n    getName () {\n        return this.getObject(LightName, LightCapabilities.KEY_NAME);\n    }\n\n    /**\n     * @param {Boolean} available - Indicates if the status (ON/OFF) can be set remotely. App shall not use read-only\n     *                              values (RAMP_UP/RAMP_DOWN/UNKNOWN/INVALID) in a setInteriorVehicleData request.\n     * @return {LightCapabilities}\n     */\n    setStatusAvailable (available) {\n        this.setParameter(LightCapabilities.KEY_STATUS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getStatusAvailable () {\n        return this.getParameter(LightCapabilities.KEY_STATUS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Indicates if the light's density can be set remotely (similar to a dimmer).\n     * @return {LightCapabilities}\n     */\n    setDensityAvailable (available) {\n        this.setParameter(LightCapabilities.KEY_DENSITY_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDensityAvailable () {\n        return this.getParameter(LightCapabilities.KEY_DENSITY_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Indicates if the light's color can be set remotely by using the sRGB color space.\n     * @return {LightCapabilities}\n     */\n    setRgbColorSpaceAvailable (available) {\n        this.setParameter(LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRgbColorSpaceAvailable () {\n        return this.getParameter(LightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE);\n    }\n}\n\nLightCapabilities.KEY_NAME = 'name';\nLightCapabilities.KEY_STATUS_AVAILABLE = 'statusAvailable';\nLightCapabilities.KEY_DENSITY_AVAILABLE = 'densityAvailable';\nLightCapabilities.KEY_RGB_COLOR_SPACE_AVAILABLE = 'rgbColorSpaceAvailable';\n\nexport { LightCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { LightCapabilities } from './LightCapabilities.js';\nimport { ModuleInfo } from './ModuleInfo.js';\n\nclass LightControlCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - The short friendly name of the light control module. It should not be used to identify a\n     *                        module by mobile application.\n     * @return {LightControlCapabilities}\n     */\n    setModuleName (name) {\n        this.setParameter(LightControlCapabilities.KEY_MODULE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleName () {\n        return this.getParameter(LightControlCapabilities.KEY_MODULE_NAME);\n    }\n\n    /**\n     * @param {ModuleInfo} info - Information about a RC module, including its id.\n     * @return {LightControlCapabilities}\n     */\n    setModuleInfo (info) {\n        this.validateType(ModuleInfo, info);\n        this.setParameter(LightControlCapabilities.KEY_MODULE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ModuleInfo}\n     */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, LightControlCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n     * @param {LightCapabilities[]} lights - An array of available LightCapabilities that are controllable.\n     * @return {LightControlCapabilities}\n     */\n    setSupportedLights (lights) {\n        this.validateType(LightCapabilities, lights, true);\n        this.setParameter(LightControlCapabilities.KEY_SUPPORTED_LIGHTS, lights);\n        return this;\n    }\n\n    /**\n     * @return {LightCapabilities[]}\n     */\n    getSupportedLights () {\n        return this.getObject(LightCapabilities, LightControlCapabilities.KEY_SUPPORTED_LIGHTS);\n    }\n}\n\nLightControlCapabilities.KEY_MODULE_NAME = 'moduleName';\nLightControlCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nLightControlCapabilities.KEY_SUPPORTED_LIGHTS = 'supportedLights';\n\nexport { LightControlCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { DefrostZone } from '../enums/DefrostZone.js';\nimport { VentilationMode } from '../enums/VentilationMode.js';\nimport { ModuleInfo } from './ModuleInfo.js';\n\n/**\n * Contains information about a climate control module's capabilities.\n */\nclass ClimateControlCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - The short friendly name of the climate control module. It should not be used to identify a\n     *                        module by mobile application.\n     * @return {ClimateControlCapabilities}\n     */\n    setModuleName (name) {\n        this.setParameter(ClimateControlCapabilities.KEY_MODULE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleName () {\n        return this.getParameter(ClimateControlCapabilities.KEY_MODULE_NAME);\n    }\n\n    /**\n     * @param {ModuleInfo} info - Information about a RC module, including its id.\n     * @return {ClimateControlCapabilities}\n     */\n    setModuleInfo (info) {\n        this.validateType(ModuleInfo, info);\n        this.setParameter(ClimateControlCapabilities.KEY_MODULE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ModuleInfo}\n     */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, ClimateControlCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the reading of current temperature. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setCurrentTemperatureAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCurrentTemperatureAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of fan speed. True: Available, False: Not Available, Not\n     *                              present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setFanSpeedAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFanSpeedAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of desired temperature. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setDesiredTemperatureAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDesiredTemperatureAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of turn on/off AC. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setAcEnableAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAcEnableAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of enable/disable air conditioning is ON on the maximum\n     *                              level. True: Available, False: Not Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setAcMaxEnableAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAcMaxEnableAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of enable/disable circulate Air mode. True: Available,\n     *                              False: Not Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setCirculateAirEnableAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCirculateAirEnableAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of enable/disable auto mode. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setAutoModeEnableAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAutoModeEnableAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of enable/disable dual mode. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setDualModeEnableAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDualModeEnableAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of defrost zones. True: Available, False: Not Available,\n     *                              Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setDefrostZoneAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDefrostZoneAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE);\n    }\n\n    /**\n     * @param {DefrostZone[]} zone - A set of all defrost zones that are controllable.\n     * @return {ClimateControlCapabilities}\n     */\n    setDefrostZone (zone) {\n        this.validateType(DefrostZone, zone, true);\n        this.setParameter(ClimateControlCapabilities.KEY_DEFROST_ZONE, zone);\n        return this;\n    }\n\n    /**\n     * @return {DefrostZone[]}\n     */\n    getDefrostZone () {\n        return this.getObject(DefrostZone, ClimateControlCapabilities.KEY_DEFROST_ZONE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of air ventilation mode. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setVentilationModeAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getVentilationModeAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE);\n    }\n\n    /**\n     * @param {VentilationMode[]} mode - A set of all ventilation modes that are controllable.\n     * @return {ClimateControlCapabilities}\n     */\n    setVentilationMode (mode) {\n        this.validateType(VentilationMode, mode, true);\n        this.setParameter(ClimateControlCapabilities.KEY_VENTILATION_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {VentilationMode[]}\n     */\n    getVentilationMode () {\n        return this.getObject(VentilationMode, ClimateControlCapabilities.KEY_VENTILATION_MODE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control (enable/disable) of heated Steering Wheel. True:\n     *                              Available, False: Not Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setHeatedSteeringWheelAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedSteeringWheelAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control (enable/disable) of heated Windshield. True: Available,\n     *                              False: Not Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setHeatedWindshieldAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedWindshieldAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control (enable/disable) of heated Rear Window. True: Available,\n     *                              False: Not Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setHeatedRearWindowAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedRearWindowAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control (enable/disable) of heated Mirrors. True: Available,\n     *                              False: Not Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setHeatedMirrorsAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatedMirrorsAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of enable/disable climate control. True: Available,\n     *                              False: Not Available, Not present: Not Available.\n     * @return {ClimateControlCapabilities}\n     */\n    setClimateEnableAvailable (available) {\n        this.setParameter(ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getClimateEnableAvailable () {\n        return this.getParameter(ClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE);\n    }\n}\n\nClimateControlCapabilities.KEY_MODULE_NAME = 'moduleName';\nClimateControlCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nClimateControlCapabilities.KEY_CURRENT_TEMPERATURE_AVAILABLE = 'currentTemperatureAvailable';\nClimateControlCapabilities.KEY_FAN_SPEED_AVAILABLE = 'fanSpeedAvailable';\nClimateControlCapabilities.KEY_DESIRED_TEMPERATURE_AVAILABLE = 'desiredTemperatureAvailable';\nClimateControlCapabilities.KEY_AC_ENABLE_AVAILABLE = 'acEnableAvailable';\nClimateControlCapabilities.KEY_AC_MAX_ENABLE_AVAILABLE = 'acMaxEnableAvailable';\nClimateControlCapabilities.KEY_CIRCULATE_AIR_ENABLE_AVAILABLE = 'circulateAirEnableAvailable';\nClimateControlCapabilities.KEY_AUTO_MODE_ENABLE_AVAILABLE = 'autoModeEnableAvailable';\nClimateControlCapabilities.KEY_DUAL_MODE_ENABLE_AVAILABLE = 'dualModeEnableAvailable';\nClimateControlCapabilities.KEY_DEFROST_ZONE_AVAILABLE = 'defrostZoneAvailable';\nClimateControlCapabilities.KEY_DEFROST_ZONE = 'defrostZone';\nClimateControlCapabilities.KEY_VENTILATION_MODE_AVAILABLE = 'ventilationModeAvailable';\nClimateControlCapabilities.KEY_VENTILATION_MODE = 'ventilationMode';\nClimateControlCapabilities.KEY_HEATED_STEERING_WHEEL_AVAILABLE = 'heatedSteeringWheelAvailable';\nClimateControlCapabilities.KEY_HEATED_WINDSHIELD_AVAILABLE = 'heatedWindshieldAvailable';\nClimateControlCapabilities.KEY_HEATED_REAR_WINDOW_AVAILABLE = 'heatedRearWindowAvailable';\nClimateControlCapabilities.KEY_HEATED_MIRRORS_AVAILABLE = 'heatedMirrorsAvailable';\nClimateControlCapabilities.KEY_CLIMATE_ENABLE_AVAILABLE = 'climateEnableAvailable';\n\nexport { ClimateControlCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ModuleInfo } from './ModuleInfo.js';\n\nclass SeatControlCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - The short friendly name of the light control module. It should not be used to identify a\n     *                        module by mobile application.\n     * @return {SeatControlCapabilities}\n     */\n    setModuleName (name) {\n        this.setParameter(SeatControlCapabilities.KEY_MODULE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleName () {\n        return this.getParameter(SeatControlCapabilities.KEY_MODULE_NAME);\n    }\n\n    /**\n     * @param {ModuleInfo} info - Information about a RC module, including its id.\n     * @return {SeatControlCapabilities}\n     */\n    setModuleInfo (info) {\n        this.validateType(ModuleInfo, info);\n        this.setParameter(SeatControlCapabilities.KEY_MODULE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ModuleInfo}\n     */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, SeatControlCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setHeatingEnabledAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatingEnabledAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setCoolingEnabledAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCoolingEnabledAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setHeatingLevelAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeatingLevelAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setCoolingLevelAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCoolingLevelAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setHorizontalPositionAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHorizontalPositionAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setVerticalPositionAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getVerticalPositionAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setFrontVerticalPositionAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getFrontVerticalPositionAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setBackVerticalPositionAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBackVerticalPositionAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setBackTiltAngleAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getBackTiltAngleAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setHeadSupportHorizontalPositionAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeadSupportHorizontalPositionAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setHeadSupportVerticalPositionAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHeadSupportVerticalPositionAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setMassageEnabledAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMassageEnabledAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setMassageModeAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMassageModeAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setMassageCushionFirmnessAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMassageCushionFirmnessAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available\n     * @return {SeatControlCapabilities}\n     */\n    setMemoryAvailable (available) {\n        this.setParameter(SeatControlCapabilities.KEY_MEMORY_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getMemoryAvailable () {\n        return this.getParameter(SeatControlCapabilities.KEY_MEMORY_AVAILABLE);\n    }\n}\n\nSeatControlCapabilities.KEY_MODULE_NAME = 'moduleName';\nSeatControlCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nSeatControlCapabilities.KEY_HEATING_ENABLED_AVAILABLE = 'heatingEnabledAvailable';\nSeatControlCapabilities.KEY_COOLING_ENABLED_AVAILABLE = 'coolingEnabledAvailable';\nSeatControlCapabilities.KEY_HEATING_LEVEL_AVAILABLE = 'heatingLevelAvailable';\nSeatControlCapabilities.KEY_COOLING_LEVEL_AVAILABLE = 'coolingLevelAvailable';\nSeatControlCapabilities.KEY_HORIZONTAL_POSITION_AVAILABLE = 'horizontalPositionAvailable';\nSeatControlCapabilities.KEY_VERTICAL_POSITION_AVAILABLE = 'verticalPositionAvailable';\nSeatControlCapabilities.KEY_FRONT_VERTICAL_POSITION_AVAILABLE = 'frontVerticalPositionAvailable';\nSeatControlCapabilities.KEY_BACK_VERTICAL_POSITION_AVAILABLE = 'backVerticalPositionAvailable';\nSeatControlCapabilities.KEY_BACK_TILT_ANGLE_AVAILABLE = 'backTiltAngleAvailable';\nSeatControlCapabilities.KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE = 'headSupportHorizontalPositionAvailable';\nSeatControlCapabilities.KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE = 'headSupportVerticalPositionAvailable';\nSeatControlCapabilities.KEY_MASSAGE_ENABLED_AVAILABLE = 'massageEnabledAvailable';\nSeatControlCapabilities.KEY_MASSAGE_MODE_AVAILABLE = 'massageModeAvailable';\nSeatControlCapabilities.KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE = 'massageCushionFirmnessAvailable';\nSeatControlCapabilities.KEY_MEMORY_AVAILABLE = 'memoryAvailable';\n\nexport { SeatControlCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ModuleInfo } from './ModuleInfo.js';\n\n/**\n * Contains information about a radio control module's capabilities.\n */\nclass RadioControlCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - The short friendly name of the climate control module. It should not be used to identify a\n     *                        module by mobile application.\n     * @return {RadioControlCapabilities}\n     */\n    setModuleName (name) {\n        this.setParameter(RadioControlCapabilities.KEY_MODULE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleName () {\n        return this.getParameter(RadioControlCapabilities.KEY_MODULE_NAME);\n    }\n\n    /**\n     * @param {ModuleInfo} info - Information about a RC module, including its id.\n     * @return {RadioControlCapabilities}\n     */\n    setModuleInfo (info) {\n        this.validateType(ModuleInfo, info);\n        this.setParameter(RadioControlCapabilities.KEY_MODULE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ModuleInfo}\n     */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, RadioControlCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of enable/disable radio. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setRadioEnableAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRadioEnableAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of radio band. True: Available, False: Not Available,\n     *                              Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setRadioBandAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRadioBandAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of radio frequency. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setRadioFrequencyAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRadioFrequencyAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of HD radio channel. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setHdChannelAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHdChannelAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the getting Radio Data System (RDS) data. True: Available, False:\n     *                              Not Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setRdsDataAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRdsDataAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_RDS_DATA_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the getting the number of available HD channels. True: Available,\n     *                              False: Not Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setAvailableHDsAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAvailableHDsAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the list of available HD sub-channel indexes. True: Available,\n     *                              False: Not Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setAvailableHdChannelsAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAvailableHdChannelsAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the getting the Radio state. True: Available, False: Not Available,\n     *                              Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setStateAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_STATE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getStateAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_STATE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the getting the signal strength. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setSignalStrengthAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSignalStrengthAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the getting the signal Change Threshold. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setSignalChangeThresholdAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSignalChangeThresholdAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the getting HD radio Station Information Service (SIS) data. True:\n     *                              Available, False: Not Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setSisDataAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSisDataAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_SIS_DATA_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of enable/disable HD radio. True: Available, False: Not\n     *                              Available, Not present: Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setHdRadioEnableAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getHdRadioEnableAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of sirius XM radio. True: Available, False: Not Available, Not present:\n     *                              Not Available.\n     * @return {RadioControlCapabilities}\n     */\n    setSiriusxmRadioAvailable (available) {\n        this.setParameter(RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSiriusxmRadioAvailable () {\n        return this.getParameter(RadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE);\n    }\n}\n\nRadioControlCapabilities.KEY_MODULE_NAME = 'moduleName';\nRadioControlCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nRadioControlCapabilities.KEY_RADIO_ENABLE_AVAILABLE = 'radioEnableAvailable';\nRadioControlCapabilities.KEY_RADIO_BAND_AVAILABLE = 'radioBandAvailable';\nRadioControlCapabilities.KEY_RADIO_FREQUENCY_AVAILABLE = 'radioFrequencyAvailable';\nRadioControlCapabilities.KEY_HD_CHANNEL_AVAILABLE = 'hdChannelAvailable';\nRadioControlCapabilities.KEY_RDS_DATA_AVAILABLE = 'rdsDataAvailable';\nRadioControlCapabilities.KEY_AVAILABLE_HDS_AVAILABLE = 'availableHDsAvailable';\nRadioControlCapabilities.KEY_AVAILABLE_HD_CHANNELS_AVAILABLE = 'availableHdChannelsAvailable';\nRadioControlCapabilities.KEY_STATE_AVAILABLE = 'stateAvailable';\nRadioControlCapabilities.KEY_SIGNAL_STRENGTH_AVAILABLE = 'signalStrengthAvailable';\nRadioControlCapabilities.KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE = 'signalChangeThresholdAvailable';\nRadioControlCapabilities.KEY_SIS_DATA_AVAILABLE = 'sisDataAvailable';\nRadioControlCapabilities.KEY_HD_RADIO_ENABLE_AVAILABLE = 'hdRadioEnableAvailable';\nRadioControlCapabilities.KEY_SIRIUSXM_RADIO_AVAILABLE = 'siriusxmRadioAvailable';\n\nexport { RadioControlCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ModuleInfo } from './ModuleInfo.js';\n\nclass HMISettingsControlCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - The short friendly name of the hmi setting module. It should not be used to identify a\n     *                        module by mobile application.\n     * @return {HMISettingsControlCapabilities}\n     */\n    setModuleName (name) {\n        this.setParameter(HMISettingsControlCapabilities.KEY_MODULE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getModuleName () {\n        return this.getParameter(HMISettingsControlCapabilities.KEY_MODULE_NAME);\n    }\n\n    /**\n     * @param {ModuleInfo} info - Information about a RC module, including its id.\n     * @return {HMISettingsControlCapabilities}\n     */\n    setModuleInfo (info) {\n        this.validateType(ModuleInfo, info);\n        this.setParameter(HMISettingsControlCapabilities.KEY_MODULE_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ModuleInfo}\n     */\n    getModuleInfo () {\n        return this.getObject(ModuleInfo, HMISettingsControlCapabilities.KEY_MODULE_INFO);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of distance unit.\n     * @return {HMISettingsControlCapabilities}\n     */\n    setDistanceUnitAvailable (available) {\n        this.setParameter(HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDistanceUnitAvailable () {\n        return this.getParameter(HMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of temperature unit.\n     * @return {HMISettingsControlCapabilities}\n     */\n    setTemperatureUnitAvailable (available) {\n        this.setParameter(HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getTemperatureUnitAvailable () {\n        return this.getParameter(HMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE);\n    }\n\n    /**\n     * @param {Boolean} available - Availability of the control of HMI display mode.\n     * @return {HMISettingsControlCapabilities}\n     */\n    setDisplayModeUnitAvailable (available) {\n        this.setParameter(HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE, available);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getDisplayModeUnitAvailable () {\n        return this.getParameter(HMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE);\n    }\n}\n\nHMISettingsControlCapabilities.KEY_MODULE_NAME = 'moduleName';\nHMISettingsControlCapabilities.KEY_MODULE_INFO = 'moduleInfo';\nHMISettingsControlCapabilities.KEY_DISTANCE_UNIT_AVAILABLE = 'distanceUnitAvailable';\nHMISettingsControlCapabilities.KEY_TEMPERATURE_UNIT_AVAILABLE = 'temperatureUnitAvailable';\nHMISettingsControlCapabilities.KEY_DISPLAY_MODE_UNIT_AVAILABLE = 'displayModeUnitAvailable';\n\nexport { HMISettingsControlCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { AudioControlCapabilities } from './AudioControlCapabilities.js';\nimport { LightControlCapabilities } from './LightControlCapabilities.js';\nimport { ClimateControlCapabilities } from './ClimateControlCapabilities.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ButtonCapabilities } from './ButtonCapabilities.js';\nimport { SeatControlCapabilities } from './SeatControlCapabilities.js';\nimport { RadioControlCapabilities } from './RadioControlCapabilities.js';\nimport { HMISettingsControlCapabilities } from './HMISettingsControlCapabilities.js';\n\nclass RemoteControlCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ClimateControlCapabilities[]} capabilities - If included, the platform supports RC climate controls. For\n     *                                                      this baseline version, maxsize=1. i.e. only one climate\n     *                                                      control module is supported.\n     * @return {RemoteControlCapabilities}\n     */\n    setClimateControlCapabilities (capabilities) {\n        this.validateType(ClimateControlCapabilities, capabilities, true);\n        this.setParameter(RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {ClimateControlCapabilities[]}\n     */\n    getClimateControlCapabilities () {\n        return this.getObject(ClimateControlCapabilities, RemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES);\n    }\n\n    /**\n     * @param {RadioControlCapabilities[]} capabilities - If included, the platform supports RC radio controls.For this\n     *                                                    baseline version, maxsize=1. i.e. only one radio control\n     *                                                    module is supported.\n     * @return {RemoteControlCapabilities}\n     */\n    setRadioControlCapabilities (capabilities) {\n        this.validateType(RadioControlCapabilities, capabilities, true);\n        this.setParameter(RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {RadioControlCapabilities[]}\n     */\n    getRadioControlCapabilities () {\n        return this.getObject(RadioControlCapabilities, RemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES);\n    }\n\n    /**\n     * @param {ButtonCapabilities[]} capabilities - If included, the platform supports RC button controls with the\n     *                                              included button names.\n     * @return {RemoteControlCapabilities}\n     */\n    setButtonCapabilities (capabilities) {\n        this.validateType(ButtonCapabilities, capabilities, true);\n        this.setParameter(RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {ButtonCapabilities[]}\n     */\n    getButtonCapabilities () {\n        return this.getObject(ButtonCapabilities, RemoteControlCapabilities.KEY_BUTTON_CAPABILITIES);\n    }\n\n    /**\n     * @param {AudioControlCapabilities[]} capabilities - If included, the platform supports audio controls.\n     * @return {RemoteControlCapabilities}\n     */\n    setAudioControlCapabilities (capabilities) {\n        this.validateType(AudioControlCapabilities, capabilities, true);\n        this.setParameter(RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {AudioControlCapabilities[]}\n     */\n    getAudioControlCapabilities () {\n        return this.getObject(AudioControlCapabilities, RemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES);\n    }\n\n    /**\n     * @param {HMISettingsControlCapabilities} capabilities - If included, the platform supports hmi setting controls.\n     * @return {RemoteControlCapabilities}\n     */\n    setHmiSettingsControlCapabilities (capabilities) {\n        this.validateType(HMISettingsControlCapabilities, capabilities);\n        this.setParameter(RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {HMISettingsControlCapabilities}\n     */\n    getHmiSettingsControlCapabilities () {\n        return this.getObject(HMISettingsControlCapabilities, RemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES);\n    }\n\n    /**\n     * @param {LightControlCapabilities} capabilities - If included, the platform supports light controls.\n     * @return {RemoteControlCapabilities}\n     */\n    setLightControlCapabilities (capabilities) {\n        this.validateType(LightControlCapabilities, capabilities);\n        this.setParameter(RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {LightControlCapabilities}\n     */\n    getLightControlCapabilities () {\n        return this.getObject(LightControlCapabilities, RemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES);\n    }\n\n    /**\n     * @param {SeatControlCapabilities[]} capabilities - If included, the platform supports seat controls.\n     * @return {RemoteControlCapabilities}\n     */\n    setSeatControlCapabilities (capabilities) {\n        this.validateType(SeatControlCapabilities, capabilities, true);\n        this.setParameter(RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {SeatControlCapabilities[]}\n     */\n    getSeatControlCapabilities () {\n        return this.getObject(SeatControlCapabilities, RemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES);\n    }\n}\n\nRemoteControlCapabilities.KEY_CLIMATE_CONTROL_CAPABILITIES = 'climateControlCapabilities';\nRemoteControlCapabilities.KEY_RADIO_CONTROL_CAPABILITIES = 'radioControlCapabilities';\nRemoteControlCapabilities.KEY_BUTTON_CAPABILITIES = 'buttonCapabilities';\nRemoteControlCapabilities.KEY_AUDIO_CONTROL_CAPABILITIES = 'audioControlCapabilities';\nRemoteControlCapabilities.KEY_HMI_SETTINGS_CONTROL_CAPABILITIES = 'hmiSettingsControlCapabilities';\nRemoteControlCapabilities.KEY_LIGHT_CONTROL_CAPABILITIES = 'lightControlCapabilities';\nRemoteControlCapabilities.KEY_SEAT_CONTROL_CAPABILITIES = 'seatControlCapabilities';\n\nexport { RemoteControlCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { SeatLocation } from './SeatLocation.js';\n\n/**\n * Contains information about the locations of each seat\n */\nclass SeatLocationCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} rows\n     * @return {SeatLocationCapability}\n     */\n    setRows (rows) {\n        this.setParameter(SeatLocationCapability.KEY_ROWS, rows);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRows () {\n        return this.getParameter(SeatLocationCapability.KEY_ROWS);\n    }\n\n    /**\n     * @param {Number} columns\n     * @return {SeatLocationCapability}\n     */\n    setColumns (columns) {\n        this.setParameter(SeatLocationCapability.KEY_COLUMNS, columns);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getColumns () {\n        return this.getParameter(SeatLocationCapability.KEY_COLUMNS);\n    }\n\n    /**\n     * @param {Number} levels\n     * @return {SeatLocationCapability}\n     */\n    setLevels (levels) {\n        this.setParameter(SeatLocationCapability.KEY_LEVELS, levels);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLevels () {\n        return this.getParameter(SeatLocationCapability.KEY_LEVELS);\n    }\n\n    /**\n     * @param {SeatLocation[]} seats - Contains a list of SeatLocation in the vehicle\n     * @return {SeatLocationCapability}\n     */\n    setSeats (seats) {\n        this.validateType(SeatLocation, seats, true);\n        this.setParameter(SeatLocationCapability.KEY_SEATS, seats);\n        return this;\n    }\n\n    /**\n     * @return {SeatLocation[]}\n     */\n    getSeats () {\n        return this.getObject(SeatLocation, SeatLocationCapability.KEY_SEATS);\n    }\n}\n\nSeatLocationCapability.KEY_ROWS = 'rows';\nSeatLocationCapability.KEY_COLUMNS = 'columns';\nSeatLocationCapability.KEY_LEVELS = 'levels';\nSeatLocationCapability.KEY_SEATS = 'seats';\n\nexport { SeatLocationCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ServiceUpdateReason\n * @property {Object} _MAP\n */\nclass ServiceUpdateReason extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The service has just been published with the module and once activated to the primary service of its type, it\n     * will be ready for possible consumption.\n     * @return {String}\n     */\n    static get PUBLISHED () {\n        return ServiceUpdateReason._MAP.PUBLISHED;\n    }\n\n    /**\n     * The service has just been unpublished with the module and is no longer accessible\n     * @return {String}\n     */\n    static get REMOVED () {\n        return ServiceUpdateReason._MAP.REMOVED;\n    }\n\n    /**\n     * The service is activated as the primary service of this type. All requests dealing with this service type will\n     * be handled by this service.\n     * @return {String}\n     */\n    static get ACTIVATED () {\n        return ServiceUpdateReason._MAP.ACTIVATED;\n    }\n\n    /**\n     * The service has been deactivated as the primary service of its type\n     * @return {String}\n     */\n    static get DEACTIVATED () {\n        return ServiceUpdateReason._MAP.DEACTIVATED;\n    }\n\n    /**\n     * The service has updated its manifest. This could imply updated capabilities\n     * @return {String}\n     */\n    static get MANIFEST_UPDATE () {\n        return ServiceUpdateReason._MAP.MANIFEST_UPDATE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ServiceUpdateReason._valueForKey(key, ServiceUpdateReason._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ServiceUpdateReason._keyForValue(value, ServiceUpdateReason._MAP);\n    }\n}\n\nServiceUpdateReason._MAP = Object.freeze({\n    'PUBLISHED': 'PUBLISHED',\n    'REMOVED': 'REMOVED',\n    'ACTIVATED': 'ACTIVATED',\n    'DEACTIVATED': 'DEACTIVATED',\n    'MANIFEST_UPDATE': 'MANIFEST_UPDATE',\n});\n\nexport { ServiceUpdateReason };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass NavigationServiceManifest extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} points - Informs the subscriber if this service can actually accept way points.\n     * @return {NavigationServiceManifest}\n     */\n    setAcceptsWayPoints (points) {\n        this.setParameter(NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS, points);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAcceptsWayPoints () {\n        return this.getParameter(NavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS);\n    }\n}\n\nNavigationServiceManifest.KEY_ACCEPTS_WAY_POINTS = 'acceptsWayPoints';\n\nexport { NavigationServiceManifest };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass WeatherServiceManifest extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} supported\n     * @return {WeatherServiceManifest}\n     */\n    setCurrentForecastSupported (supported) {\n        this.setParameter(WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getCurrentForecastSupported () {\n        return this.getParameter(WeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED);\n    }\n\n    /**\n     * @param {Number} amount\n     * @return {WeatherServiceManifest}\n     */\n    setMaxMultidayForecastAmount (amount) {\n        this.setParameter(WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT, amount);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaxMultidayForecastAmount () {\n        return this.getParameter(WeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT);\n    }\n\n    /**\n     * @param {Number} amount\n     * @return {WeatherServiceManifest}\n     */\n    setMaxHourlyForecastAmount (amount) {\n        this.setParameter(WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT, amount);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaxHourlyForecastAmount () {\n        return this.getParameter(WeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT);\n    }\n\n    /**\n     * @param {Number} amount\n     * @return {WeatherServiceManifest}\n     */\n    setMaxMinutelyForecastAmount (amount) {\n        this.setParameter(WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT, amount);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMaxMinutelyForecastAmount () {\n        return this.getParameter(WeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT);\n    }\n\n    /**\n     * @param {Boolean} supported\n     * @return {WeatherServiceManifest}\n     */\n    setWeatherForLocationSupported (supported) {\n        this.setParameter(WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED, supported);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getWeatherForLocationSupported () {\n        return this.getParameter(WeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED);\n    }\n}\n\nWeatherServiceManifest.KEY_CURRENT_FORECAST_SUPPORTED = 'currentForecastSupported';\nWeatherServiceManifest.KEY_MAX_MULTIDAY_FORECAST_AMOUNT = 'maxMultidayForecastAmount';\nWeatherServiceManifest.KEY_MAX_HOURLY_FORECAST_AMOUNT = 'maxHourlyForecastAmount';\nWeatherServiceManifest.KEY_MAX_MINUTELY_FORECAST_AMOUNT = 'maxMinutelyForecastAmount';\nWeatherServiceManifest.KEY_WEATHER_FOR_LOCATION_SUPPORTED = 'weatherForLocationSupported';\n\nexport { WeatherServiceManifest };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass MediaServiceManifest extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n}\n\n\nexport { MediaServiceManifest };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { NavigationServiceManifest } from './NavigationServiceManifest.js';\nimport { Image } from './Image.js';\nimport { SdlMsgVersion } from './SdlMsgVersion.js';\nimport { WeatherServiceManifest } from './WeatherServiceManifest.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { MediaServiceManifest } from './MediaServiceManifest.js';\n\n/**\n * This manifest contains all the information necessary for the service to be published, activated, and consumers able\n * to interact with it\n */\nclass AppServiceManifest extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - Unique name of this service\n     * @return {AppServiceManifest}\n     */\n    setServiceName (name) {\n        this.setParameter(AppServiceManifest.KEY_SERVICE_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceName () {\n        return this.getParameter(AppServiceManifest.KEY_SERVICE_NAME);\n    }\n\n    /**\n     * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum\n     *                        equivalent types. Parameter is a string to allow for new service types to be used by apps\n     *                        on older versions of SDL Core.\n     * @return {AppServiceManifest}\n     */\n    setServiceType (type) {\n        this.setParameter(AppServiceManifest.KEY_SERVICE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceType () {\n        return this.getParameter(AppServiceManifest.KEY_SERVICE_TYPE);\n    }\n\n    /**\n     * @param {Image} icon - The icon to be associated with this service. Most likely the same as the appIcon.\n     * @return {AppServiceManifest}\n     */\n    setServiceIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(AppServiceManifest.KEY_SERVICE_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getServiceIcon () {\n        return this.getObject(Image, AppServiceManifest.KEY_SERVICE_ICON);\n    }\n\n    /**\n     * @param {Boolean} consumers - If true, app service consumers beyond the IVI system will be able to access this\n     *                              service. If false, only the IVI system will be able consume the service. If not\n     *                              provided, it is assumed to be false.\n     * @return {AppServiceManifest}\n     */\n    setAllowAppConsumers (consumers) {\n        this.setParameter(AppServiceManifest.KEY_ALLOW_APP_CONSUMERS, consumers);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAllowAppConsumers () {\n        return this.getParameter(AppServiceManifest.KEY_ALLOW_APP_CONSUMERS);\n    }\n\n    /**\n     * @param {SdlMsgVersion} version - This is the max RPC Spec version the app service understands. This is important\n     *                                  during the RPC passthrough functionality. If not included, it is assumed the max\n     *                                  version of the module is acceptable.\n     * @return {AppServiceManifest}\n     */\n    setRpcSpecVersion (version) {\n        this.validateType(SdlMsgVersion, version);\n        this.setParameter(AppServiceManifest.KEY_RPC_SPEC_VERSION, version);\n        return this;\n    }\n\n    /**\n     * @return {SdlMsgVersion}\n     */\n    getRpcSpecVersion () {\n        return this.getObject(SdlMsgVersion, AppServiceManifest.KEY_RPC_SPEC_VERSION);\n    }\n\n    /**\n     * @param {Number[]} cs - This field contains the Function IDs for the RPCs that this service intends to handle\n     *                        correctly. This means the service will provide meaningful responses.\n     * @return {AppServiceManifest}\n     */\n    setHandledRPCs (cs) {\n        this.setParameter(AppServiceManifest.KEY_HANDLED_RPCS, cs);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getHandledRPCs () {\n        return this.getParameter(AppServiceManifest.KEY_HANDLED_RPCS);\n    }\n\n    /**\n     * @param {MediaServiceManifest} manifest\n     * @return {AppServiceManifest}\n     */\n    setMediaServiceManifest (manifest) {\n        this.validateType(MediaServiceManifest, manifest);\n        this.setParameter(AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST, manifest);\n        return this;\n    }\n\n    /**\n     * @return {MediaServiceManifest}\n     */\n    getMediaServiceManifest () {\n        return this.getObject(MediaServiceManifest, AppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST);\n    }\n\n    /**\n     * @param {WeatherServiceManifest} manifest\n     * @return {AppServiceManifest}\n     */\n    setWeatherServiceManifest (manifest) {\n        this.validateType(WeatherServiceManifest, manifest);\n        this.setParameter(AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST, manifest);\n        return this;\n    }\n\n    /**\n     * @return {WeatherServiceManifest}\n     */\n    getWeatherServiceManifest () {\n        return this.getObject(WeatherServiceManifest, AppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST);\n    }\n\n    /**\n     * @param {NavigationServiceManifest} manifest\n     * @return {AppServiceManifest}\n     */\n    setNavigationServiceManifest (manifest) {\n        this.validateType(NavigationServiceManifest, manifest);\n        this.setParameter(AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST, manifest);\n        return this;\n    }\n\n    /**\n     * @return {NavigationServiceManifest}\n     */\n    getNavigationServiceManifest () {\n        return this.getObject(NavigationServiceManifest, AppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST);\n    }\n}\n\nAppServiceManifest.KEY_SERVICE_NAME = 'serviceName';\nAppServiceManifest.KEY_SERVICE_TYPE = 'serviceType';\nAppServiceManifest.KEY_SERVICE_ICON = 'serviceIcon';\nAppServiceManifest.KEY_ALLOW_APP_CONSUMERS = 'allowAppConsumers';\nAppServiceManifest.KEY_RPC_SPEC_VERSION = 'rpcSpecVersion';\nAppServiceManifest.KEY_HANDLED_RPCS = 'handledRPCs';\nAppServiceManifest.KEY_MEDIA_SERVICE_MANIFEST = 'mediaServiceManifest';\nAppServiceManifest.KEY_WEATHER_SERVICE_MANIFEST = 'weatherServiceManifest';\nAppServiceManifest.KEY_NAVIGATION_SERVICE_MANIFEST = 'navigationServiceManifest';\n\nexport { AppServiceManifest };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { AppServiceManifest } from './AppServiceManifest.js';\n\n/**\n * This is the record of an app service publisher that the module has. It should contain the most up to date\n * information including the service's active state\n */\nclass AppServiceRecord extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} id - A unique ID tied to this specific service record. The ID is supplied by the module that\n     *                      services publish themselves.\n     * @return {AppServiceRecord}\n     */\n    setServiceID (id) {\n        this.setParameter(AppServiceRecord.KEY_SERVICE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceID () {\n        return this.getParameter(AppServiceRecord.KEY_SERVICE_ID);\n    }\n\n    /**\n     * @param {AppServiceManifest} manifest - Manifest for the service that this record is for.\n     * @return {AppServiceRecord}\n     */\n    setServiceManifest (manifest) {\n        this.validateType(AppServiceManifest, manifest);\n        this.setParameter(AppServiceRecord.KEY_SERVICE_MANIFEST, manifest);\n        return this;\n    }\n\n    /**\n     * @return {AppServiceManifest}\n     */\n    getServiceManifest () {\n        return this.getObject(AppServiceManifest, AppServiceRecord.KEY_SERVICE_MANIFEST);\n    }\n\n    /**\n     * @param {Boolean} published - If true, the service is published and available. If false, the service has likely\n     *                              just been unpublished, and should be considered unavailable.\n     * @return {AppServiceRecord}\n     */\n    setServicePublished (published) {\n        this.setParameter(AppServiceRecord.KEY_SERVICE_PUBLISHED, published);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getServicePublished () {\n        return this.getParameter(AppServiceRecord.KEY_SERVICE_PUBLISHED);\n    }\n\n    /**\n     * @param {Boolean} active - If true, the service is the active primary service of the supplied service type. It\n     *                           will receive all potential RPCs that are passed through to that service type. If false,\n     *                           it is not the primary service of the supplied type. See servicePublished for its\n     *                           availability.\n     * @return {AppServiceRecord}\n     */\n    setServiceActive (active) {\n        this.setParameter(AppServiceRecord.KEY_SERVICE_ACTIVE, active);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getServiceActive () {\n        return this.getParameter(AppServiceRecord.KEY_SERVICE_ACTIVE);\n    }\n}\n\nAppServiceRecord.KEY_SERVICE_ID = 'serviceID';\nAppServiceRecord.KEY_SERVICE_MANIFEST = 'serviceManifest';\nAppServiceRecord.KEY_SERVICE_PUBLISHED = 'servicePublished';\nAppServiceRecord.KEY_SERVICE_ACTIVE = 'serviceActive';\n\nexport { AppServiceRecord };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { ServiceUpdateReason } from '../enums/ServiceUpdateReason.js';\nimport { AppServiceRecord } from './AppServiceRecord.js';\n\nclass AppServiceCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {ServiceUpdateReason} reason - Only included in OnSystemCapabilityUpdated. Update reason for service\n     *                                       record.\n     * @return {AppServiceCapability}\n     */\n    setUpdateReason (reason) {\n        this.validateType(ServiceUpdateReason, reason);\n        this.setParameter(AppServiceCapability.KEY_UPDATE_REASON, reason);\n        return this;\n    }\n\n    /**\n     * @return {ServiceUpdateReason}\n     */\n    getUpdateReason () {\n        return this.getObject(ServiceUpdateReason, AppServiceCapability.KEY_UPDATE_REASON);\n    }\n\n    /**\n     * @param {AppServiceRecord} record - Service record for a specific app service provider\n     * @return {AppServiceCapability}\n     */\n    setUpdatedAppServiceRecord (record) {\n        this.validateType(AppServiceRecord, record);\n        this.setParameter(AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD, record);\n        return this;\n    }\n\n    /**\n     * @return {AppServiceRecord}\n     */\n    getUpdatedAppServiceRecord () {\n        return this.getObject(AppServiceRecord, AppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD);\n    }\n}\n\nAppServiceCapability.KEY_UPDATE_REASON = 'updateReason';\nAppServiceCapability.KEY_UPDATED_APP_SERVICE_RECORD = 'updatedAppServiceRecord';\n\nexport { AppServiceCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { AppServiceCapability } from './AppServiceCapability.js';\n\n/**\n * Capabilities of app services including what service types are supported and the current state of services.\n */\nclass AppServicesCapabilities extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {AppServiceCapability[]} services - An array of currently available services. If this is an update to the\n     *                                            capability the affected services will include an update reason in that\n     *                                            item\n     * @return {AppServicesCapabilities}\n     */\n    setAppServices (services) {\n        this.validateType(AppServiceCapability, services, true);\n        this.setParameter(AppServicesCapabilities.KEY_APP_SERVICES, services);\n        return this;\n    }\n\n    /**\n     * @return {AppServiceCapability[]}\n     */\n    getAppServices () {\n        return this.getObject(AppServiceCapability, AppServicesCapabilities.KEY_APP_SERVICES);\n    }\n}\n\nAppServicesCapabilities.KEY_APP_SERVICES = 'appServices';\n\nexport { AppServicesCapabilities };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Extended capabilities for an onboard navigation system\n */\nclass NavigationCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Boolean} enabled - If the module has the ability to add locations to the onboard nav\n     * @return {NavigationCapability}\n     */\n    setSendLocationEnabled (enabled) {\n        this.setParameter(NavigationCapability.KEY_SEND_LOCATION_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSendLocationEnabled () {\n        return this.getParameter(NavigationCapability.KEY_SEND_LOCATION_ENABLED);\n    }\n\n    /**\n     * @param {Boolean} enabled - If the module has the ability to return way points from onboard nav\n     * @return {NavigationCapability}\n     */\n    setGetWayPointsEnabled (enabled) {\n        this.setParameter(NavigationCapability.KEY_GET_WAY_POINTS_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getGetWayPointsEnabled () {\n        return this.getParameter(NavigationCapability.KEY_GET_WAY_POINTS_ENABLED);\n    }\n}\n\nNavigationCapability.KEY_SEND_LOCATION_ENABLED = 'sendLocationEnabled';\nNavigationCapability.KEY_GET_WAY_POINTS_ENABLED = 'getWayPointsEnabled';\n\nexport { NavigationCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { VideoStreamingCapability } from './VideoStreamingCapability.js';\nimport { PhoneCapability } from './PhoneCapability.js';\nimport { DisplayCapability } from './DisplayCapability.js';\nimport { RemoteControlCapabilities } from './RemoteControlCapabilities.js';\nimport { SeatLocationCapability } from './SeatLocationCapability.js';\nimport { SystemCapabilityType } from '../enums/SystemCapabilityType.js';\nimport { AppServicesCapabilities } from './AppServicesCapabilities.js';\nimport { NavigationCapability } from './NavigationCapability.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * The systemCapabilityType identifies which data object exists in this struct. For example, if the SystemCapability\n * Type is NAVIGATION then a \"navigationCapability\" should exist\n */\nclass SystemCapability extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {SystemCapabilityType} type - Used as a descriptor of what data to expect in this struct. The\n     *                                      corresponding param to this enum should be included and the only other param\n     *                                      included.\n     * @return {SystemCapability}\n     */\n    setSystemCapabilityType (type) {\n        this.validateType(SystemCapabilityType, type);\n        this.setParameter(SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {SystemCapabilityType}\n     */\n    getSystemCapabilityType () {\n        return this.getObject(SystemCapabilityType, SystemCapability.KEY_SYSTEM_CAPABILITY_TYPE);\n    }\n\n    /**\n     * @param {NavigationCapability} capability - Describes extended capabilities for onboard navigation system\n     * @return {SystemCapability}\n     */\n    setNavigationCapability (capability) {\n        this.validateType(NavigationCapability, capability);\n        this.setParameter(SystemCapability.KEY_NAVIGATION_CAPABILITY, capability);\n        return this;\n    }\n\n    /**\n     * @return {NavigationCapability}\n     */\n    getNavigationCapability () {\n        return this.getObject(NavigationCapability, SystemCapability.KEY_NAVIGATION_CAPABILITY);\n    }\n\n    /**\n     * @param {PhoneCapability} capability - Describes extended capabilities of the module's phone feature\n     * @return {SystemCapability}\n     */\n    setPhoneCapability (capability) {\n        this.validateType(PhoneCapability, capability);\n        this.setParameter(SystemCapability.KEY_PHONE_CAPABILITY, capability);\n        return this;\n    }\n\n    /**\n     * @return {PhoneCapability}\n     */\n    getPhoneCapability () {\n        return this.getObject(PhoneCapability, SystemCapability.KEY_PHONE_CAPABILITY);\n    }\n\n    /**\n     * @param {VideoStreamingCapability} capability - Describes extended capabilities of the module's phone feature\n     * @return {SystemCapability}\n     */\n    setVideoStreamingCapability (capability) {\n        this.validateType(VideoStreamingCapability, capability);\n        this.setParameter(SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY, capability);\n        return this;\n    }\n\n    /**\n     * @return {VideoStreamingCapability}\n     */\n    getVideoStreamingCapability () {\n        return this.getObject(VideoStreamingCapability, SystemCapability.KEY_VIDEO_STREAMING_CAPABILITY);\n    }\n\n    /**\n     * @param {RemoteControlCapabilities} capability - Describes extended capabilities of the module's phone feature\n     * @return {SystemCapability}\n     */\n    setRemoteControlCapability (capability) {\n        this.validateType(RemoteControlCapabilities, capability);\n        this.setParameter(SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY, capability);\n        return this;\n    }\n\n    /**\n     * @return {RemoteControlCapabilities}\n     */\n    getRemoteControlCapability () {\n        return this.getObject(RemoteControlCapabilities, SystemCapability.KEY_REMOTE_CONTROL_CAPABILITY);\n    }\n\n    /**\n     * @param {AppServicesCapabilities} capabilities - An array of currently available services. If this is an update to\n     *                                                 the capability the affected services will include an update\n     *                                                 reason in that item\n     * @return {SystemCapability}\n     */\n    setAppServicesCapabilities (capabilities) {\n        this.validateType(AppServicesCapabilities, capabilities);\n        this.setParameter(SystemCapability.KEY_APP_SERVICES_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {AppServicesCapabilities}\n     */\n    getAppServicesCapabilities () {\n        return this.getObject(AppServicesCapabilities, SystemCapability.KEY_APP_SERVICES_CAPABILITIES);\n    }\n\n    /**\n     * @param {SeatLocationCapability} capability - Contains information about the locations of each seat\n     * @return {SystemCapability}\n     */\n    setSeatLocationCapability (capability) {\n        this.validateType(SeatLocationCapability, capability);\n        this.setParameter(SystemCapability.KEY_SEAT_LOCATION_CAPABILITY, capability);\n        return this;\n    }\n\n    /**\n     * @return {SeatLocationCapability}\n     */\n    getSeatLocationCapability () {\n        return this.getObject(SeatLocationCapability, SystemCapability.KEY_SEAT_LOCATION_CAPABILITY);\n    }\n\n    /**\n     * @param {DisplayCapability[]} capabilities\n     * @return {SystemCapability}\n     */\n    setDisplayCapabilities (capabilities) {\n        this.validateType(DisplayCapability, capabilities, true);\n        this.setParameter(SystemCapability.KEY_DISPLAY_CAPABILITIES, capabilities);\n        return this;\n    }\n\n    /**\n     * @return {DisplayCapability[]}\n     */\n    getDisplayCapabilities () {\n        return this.getObject(DisplayCapability, SystemCapability.KEY_DISPLAY_CAPABILITIES);\n    }\n}\n\nSystemCapability.KEY_SYSTEM_CAPABILITY_TYPE = 'systemCapabilityType';\nSystemCapability.KEY_NAVIGATION_CAPABILITY = 'navigationCapability';\nSystemCapability.KEY_PHONE_CAPABILITY = 'phoneCapability';\nSystemCapability.KEY_VIDEO_STREAMING_CAPABILITY = 'videoStreamingCapability';\nSystemCapability.KEY_REMOTE_CONTROL_CAPABILITY = 'remoteControlCapability';\nSystemCapability.KEY_APP_SERVICES_CAPABILITIES = 'appServicesCapabilities';\nSystemCapability.KEY_SEAT_LOCATION_CAPABILITY = 'seatLocationCapability';\nSystemCapability.KEY_DISPLAY_CAPABILITIES = 'displayCapabilities';\n\nexport { SystemCapability };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\nimport { SystemCapability } from '../structs/SystemCapability.js';\n\nclass GetSystemCapabilityResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetSystemCapability);\n    }\n\n    /**\n     * @param {SystemCapability} capability - The systemCapabilityType identifies which data object exists in this\n     *                                        struct. For example, if the SystemCapability Type is NAVIGATION then a\n     *                                        \"navigationCapability\" should exist\n     * @return {GetSystemCapabilityResponse}\n     */\n    setSystemCapability (capability) {\n        this.validateType(SystemCapability, capability);\n        this.setParameter(GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY, capability);\n        return this;\n    }\n\n    /**\n     * @return {SystemCapability}\n     */\n    getSystemCapability () {\n        return this.getObject(SystemCapability, GetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY);\n    }\n}\n\nGetSystemCapabilityResponse.KEY_SYSTEM_CAPABILITY = 'systemCapability';\n\nexport { GetSystemCapabilityResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass Rectangle extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} x - The upper left X-coordinate of the rectangle\n     * @return {Rectangle}\n     */\n    setX (x) {\n        this.setParameter(Rectangle.KEY_X, x);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getX () {\n        return this.getParameter(Rectangle.KEY_X);\n    }\n\n    /**\n     * @param {Number} y - The upper left Y-coordinate of the rectangle\n     * @return {Rectangle}\n     */\n    setY (y) {\n        this.setParameter(Rectangle.KEY_Y, y);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getY () {\n        return this.getParameter(Rectangle.KEY_Y);\n    }\n\n    /**\n     * @param {Number} width - The width of the rectangle\n     * @return {Rectangle}\n     */\n    setWidth (width) {\n        this.setParameter(Rectangle.KEY_WIDTH, width);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWidth () {\n        return this.getParameter(Rectangle.KEY_WIDTH);\n    }\n\n    /**\n     * @param {Number} height - The height of the rectangle\n     * @return {Rectangle}\n     */\n    setHeight (height) {\n        this.setParameter(Rectangle.KEY_HEIGHT, height);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHeight () {\n        return this.getParameter(Rectangle.KEY_HEIGHT);\n    }\n}\n\nRectangle.KEY_X = 'x';\nRectangle.KEY_Y = 'y';\nRectangle.KEY_WIDTH = 'width';\nRectangle.KEY_HEIGHT = 'height';\n\nexport { Rectangle };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Rectangle } from './Rectangle.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\n/**\n * Defines haptic data for each user control object for video streaming application\n */\nclass HapticRect extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} id - A user control spatial identifier\n     * @return {HapticRect}\n     */\n    setId (id) {\n        this.setParameter(HapticRect.KEY_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getId () {\n        return this.getParameter(HapticRect.KEY_ID);\n    }\n\n    /**\n     * @param {Rectangle} rect - The position of the haptic rectangle to be highlighted. The center of this rectangle\n     *                           will be \"touched\" when a press occurs.\n     * @return {HapticRect}\n     */\n    setRect (rect) {\n        this.validateType(Rectangle, rect);\n        this.setParameter(HapticRect.KEY_RECT, rect);\n        return this;\n    }\n\n    /**\n     * @return {Rectangle}\n     */\n    getRect () {\n        return this.getObject(Rectangle, HapticRect.KEY_RECT);\n    }\n}\n\nHapticRect.KEY_ID = 'id';\nHapticRect.KEY_RECT = 'rect';\n\nexport { HapticRect };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { HapticRect } from '../structs/HapticRect.js';\n\n/**\n * Send the spatial data gathered from SDLCarWindow or VirtualDisplayEncoder to the HMI. This data will be utilized by\n * the HMI to determine how and when haptic events should occur\n */\nclass SendHapticData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SendHapticData);\n    }\n\n    /**\n     * @param {HapticRect[]} data - Array of spatial data structures that represent the locations of all user controls\n     *                              present on the HMI. This data should be updated if/when the application presents a\n     *                              new screen. When a request is sent, if successful, it will replace all spatial data\n     *                              previously sent through RPC. If an empty array is sent, the existing spatial data\n     *                              will be cleared\n     * @return {SendHapticData}\n     */\n    setHapticRectData (data) {\n        this.validateType(HapticRect, data, true);\n        this.setParameter(SendHapticData.KEY_HAPTIC_RECT_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {HapticRect[]}\n     */\n    getHapticRectData () {\n        return this.getObject(HapticRect, SendHapticData.KEY_HAPTIC_RECT_DATA);\n    }\n}\n\nSendHapticData.KEY_HAPTIC_RECT_DATA = 'hapticRectData';\n\nexport { SendHapticData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass SendHapticDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SendHapticData);\n    }\n}\n\n\nexport { SendHapticDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration for the user's preference of which app type to use when both are available\n * @typedef {Enum} HybridAppPreference\n * @property {Object} _MAP\n */\nclass HybridAppPreference extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MOBILE () {\n        return HybridAppPreference._MAP.MOBILE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CLOUD () {\n        return HybridAppPreference._MAP.CLOUD;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BOTH () {\n        return HybridAppPreference._MAP.BOTH;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return HybridAppPreference._valueForKey(key, HybridAppPreference._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return HybridAppPreference._keyForValue(value, HybridAppPreference._MAP);\n    }\n}\n\nHybridAppPreference._MAP = Object.freeze({\n    'MOBILE': 'MOBILE',\n    'CLOUD': 'CLOUD',\n    'BOTH': 'BOTH',\n});\n\nexport { HybridAppPreference };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { HybridAppPreference } from '../enums/HybridAppPreference.js';\n\nclass CloudAppProperties extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String[]} nicknames - An array of app names a cloud app is allowed to register with. If included in a\n     *                               SetCloudAppProperties request, this value will overwrite the existing \"nicknames\"\n     *                               field in the app policies section of the policy table.\n     * @return {CloudAppProperties}\n     */\n    setNicknames (nicknames) {\n        this.setParameter(CloudAppProperties.KEY_NICKNAMES, nicknames);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getNicknames () {\n        return this.getParameter(CloudAppProperties.KEY_NICKNAMES);\n    }\n\n    /**\n     * @param {String} id\n     * @return {CloudAppProperties}\n     */\n    setAppID (id) {\n        this.setParameter(CloudAppProperties.KEY_APP_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppID () {\n        return this.getParameter(CloudAppProperties.KEY_APP_ID);\n    }\n\n    /**\n     * @param {Boolean} enabled - If true, cloud app will be included in HMI RPC UpdateAppList\n     * @return {CloudAppProperties}\n     */\n    setEnabled (enabled) {\n        this.setParameter(CloudAppProperties.KEY_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getEnabled () {\n        return this.getParameter(CloudAppProperties.KEY_ENABLED);\n    }\n\n    /**\n     * @param {String} token - Used to authenticate websocket connection on app activation\n     * @return {CloudAppProperties}\n     */\n    setAuthToken (token) {\n        this.setParameter(CloudAppProperties.KEY_AUTH_TOKEN, token);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAuthToken () {\n        return this.getParameter(CloudAppProperties.KEY_AUTH_TOKEN);\n    }\n\n    /**\n     * @param {String} type - Specifies the connection type Core should use\n     * @return {CloudAppProperties}\n     */\n    setCloudTransportType (type) {\n        this.setParameter(CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getCloudTransportType () {\n        return this.getParameter(CloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE);\n    }\n\n    /**\n     * @param {HybridAppPreference} preference - Specifies the user preference to use the cloud app version or mobile\n     *                                           app version when both are available\n     * @return {CloudAppProperties}\n     */\n    setHybridAppPreference (preference) {\n        this.validateType(HybridAppPreference, preference);\n        this.setParameter(CloudAppProperties.KEY_HYBRID_APP_PREFERENCE, preference);\n        return this;\n    }\n\n    /**\n     * @return {HybridAppPreference}\n     */\n    getHybridAppPreference () {\n        return this.getObject(HybridAppPreference, CloudAppProperties.KEY_HYBRID_APP_PREFERENCE);\n    }\n\n    /**\n     * @param {String} endpoint - Specifies the endpoint which Core will attempt to connect to when this app is selected\n     * @return {CloudAppProperties}\n     */\n    setEndpoint (endpoint) {\n        this.setParameter(CloudAppProperties.KEY_ENDPOINT, endpoint);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getEndpoint () {\n        return this.getParameter(CloudAppProperties.KEY_ENDPOINT);\n    }\n}\n\nCloudAppProperties.KEY_NICKNAMES = 'nicknames';\nCloudAppProperties.KEY_APP_ID = 'appID';\nCloudAppProperties.KEY_ENABLED = 'enabled';\nCloudAppProperties.KEY_AUTH_TOKEN = 'authToken';\nCloudAppProperties.KEY_CLOUD_TRANSPORT_TYPE = 'cloudTransportType';\nCloudAppProperties.KEY_HYBRID_APP_PREFERENCE = 'hybridAppPreference';\nCloudAppProperties.KEY_ENDPOINT = 'endpoint';\n\nexport { CloudAppProperties };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { CloudAppProperties } from '../structs/CloudAppProperties.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * RPC used to enable/disable a cloud application and set its cloud-related policy properties\n */\nclass SetCloudAppProperties extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetCloudAppProperties);\n    }\n\n    /**\n     * @param {CloudAppProperties} properties - The new cloud application properties\n     * @return {SetCloudAppProperties}\n     */\n    setProperties (properties) {\n        this.validateType(CloudAppProperties, properties);\n        this.setParameter(SetCloudAppProperties.KEY_PROPERTIES, properties);\n        return this;\n    }\n\n    /**\n     * @return {CloudAppProperties}\n     */\n    getProperties () {\n        return this.getObject(CloudAppProperties, SetCloudAppProperties.KEY_PROPERTIES);\n    }\n}\n\nSetCloudAppProperties.KEY_PROPERTIES = 'properties';\n\nexport { SetCloudAppProperties };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * The response to SetCloudAppProperties\n */\nclass SetCloudAppPropertiesResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.SetCloudAppProperties);\n    }\n}\n\n\nexport { SetCloudAppPropertiesResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * RPC used to get the current properties of a cloud application\n */\nclass GetCloudAppProperties extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetCloudAppProperties);\n    }\n\n    /**\n     * @param {String} id\n     * @return {GetCloudAppProperties}\n     */\n    setAppID (id) {\n        this.setParameter(GetCloudAppProperties.KEY_APP_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getAppID () {\n        return this.getParameter(GetCloudAppProperties.KEY_APP_ID);\n    }\n}\n\nGetCloudAppProperties.KEY_APP_ID = 'appID';\n\nexport { GetCloudAppProperties };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { CloudAppProperties } from '../structs/CloudAppProperties.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * The response to GetCloudAppProperties\n */\nclass GetCloudAppPropertiesResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetCloudAppProperties);\n    }\n\n    /**\n     * @param {CloudAppProperties} properties - The requested cloud application properties\n     * @return {GetCloudAppPropertiesResponse}\n     */\n    setProperties (properties) {\n        this.validateType(CloudAppProperties, properties);\n        this.setParameter(GetCloudAppPropertiesResponse.KEY_PROPERTIES, properties);\n        return this;\n    }\n\n    /**\n     * @return {CloudAppProperties}\n     */\n    getProperties () {\n        return this.getObject(CloudAppProperties, GetCloudAppPropertiesResponse.KEY_PROPERTIES);\n    }\n}\n\nGetCloudAppPropertiesResponse.KEY_PROPERTIES = 'properties';\n\nexport { GetCloudAppPropertiesResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { AppServiceManifest } from '../structs/AppServiceManifest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Registers a service offered by this app on the module. Subsequent calls with the same service type will update the\n * manifest for that service.\n */\nclass PublishAppService extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PublishAppService);\n    }\n\n    /**\n     * @param {AppServiceManifest} manifest - The manifest of the service that wishes to be published. If already\n     *                                        published, the updated manifest for this service.\n     * @return {PublishAppService}\n     */\n    setAppServiceManifest (manifest) {\n        this.validateType(AppServiceManifest, manifest);\n        this.setParameter(PublishAppService.KEY_APP_SERVICE_MANIFEST, manifest);\n        return this;\n    }\n\n    /**\n     * @return {AppServiceManifest}\n     */\n    getAppServiceManifest () {\n        return this.getObject(AppServiceManifest, PublishAppService.KEY_APP_SERVICE_MANIFEST);\n    }\n}\n\nPublishAppService.KEY_APP_SERVICE_MANIFEST = 'appServiceManifest';\n\nexport { PublishAppService };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\nimport { AppServiceRecord } from '../structs/AppServiceRecord.js';\n\n/**\n * Response to the request to register a service offered by this app on the module\n */\nclass PublishAppServiceResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PublishAppService);\n    }\n\n    /**\n     * @param {AppServiceRecord} record - If the request was successful, this object will be the current status of the\n     *                                    service record for the published service. This will include the Core supplied\n     *                                    service ID.\n     * @return {PublishAppServiceResponse}\n     */\n    setAppServiceRecord (record) {\n        this.validateType(AppServiceRecord, record);\n        this.setParameter(PublishAppServiceResponse.KEY_APP_SERVICE_RECORD, record);\n        return this;\n    }\n\n    /**\n     * @return {AppServiceRecord}\n     */\n    getAppServiceRecord () {\n        return this.getObject(AppServiceRecord, PublishAppServiceResponse.KEY_APP_SERVICE_RECORD);\n    }\n}\n\nPublishAppServiceResponse.KEY_APP_SERVICE_RECORD = 'appServiceRecord';\n\nexport { PublishAppServiceResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Unpublish an existing service published by this application.\n */\nclass UnpublishAppService extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnpublishAppService);\n    }\n\n    /**\n     * @param {String} id - The ID of the service to be unpublished.\n     * @return {UnpublishAppService}\n     */\n    setServiceID (id) {\n        this.setParameter(UnpublishAppService.KEY_SERVICE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceID () {\n        return this.getParameter(UnpublishAppService.KEY_SERVICE_ID);\n    }\n}\n\nUnpublishAppService.KEY_SERVICE_ID = 'serviceID';\n\nexport { UnpublishAppService };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * The response to UnpublishAppService\n */\nclass UnpublishAppServiceResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.UnpublishAppService);\n    }\n}\n\n\nexport { UnpublishAppServiceResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * This request asks the module for current data related to the specific service. It also includes an option to\n * subscribe to that service for future updates\n */\nclass GetAppServiceData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetAppServiceData);\n    }\n\n    /**\n     * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum\n     *                        equivalent types. Parameter is a string to allow for new service types to be used by apps\n     *                        on older versions of SDL Core.\n     * @return {GetAppServiceData}\n     */\n    setServiceType (type) {\n        this.setParameter(GetAppServiceData.KEY_SERVICE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceType () {\n        return this.getParameter(GetAppServiceData.KEY_SERVICE_TYPE);\n    }\n\n    /**\n     * @param {Boolean} subscribe - If true, the consumer is requesting to subscribe to all future updates from the\n     *                              service publisher. If false, the consumer doesn't wish to subscribe and should be\n     *                              unsubscribed if it was previously subscribed.\n     * @return {GetAppServiceData}\n     */\n    setSubscribe (subscribe) {\n        this.setParameter(GetAppServiceData.KEY_SUBSCRIBE, subscribe);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getSubscribe () {\n        return this.getParameter(GetAppServiceData.KEY_SUBSCRIBE);\n    }\n}\n\nGetAppServiceData.KEY_SERVICE_TYPE = 'serviceType';\nGetAppServiceData.KEY_SUBSCRIBE = 'subscribe';\n\nexport { GetAppServiceData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} NavigationJunction\n * @property {Object} _MAP\n */\nclass NavigationJunction extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * A junction that represents a standard intersection with a single road crossing another.\n     * @return {String}\n     */\n    static get REGULAR () {\n        return NavigationJunction._MAP.REGULAR;\n    }\n\n    /**\n     * A junction where the road splits off into two paths; a fork in the road.\n     * @return {String}\n     */\n    static get BIFURCATION () {\n        return NavigationJunction._MAP.BIFURCATION;\n    }\n\n    /**\n     * A junction that has multiple intersections and paths.\n     * @return {String}\n     */\n    static get MULTI_CARRIAGEWAY () {\n        return NavigationJunction._MAP.MULTI_CARRIAGEWAY;\n    }\n\n    /**\n     * A junction where traffic moves in a single direction around a central, non-traversable point to reach one of\n     * the connecting roads.\n     * @return {String}\n     */\n    static get ROUNDABOUT () {\n        return NavigationJunction._MAP.ROUNDABOUT;\n    }\n\n    /**\n     * Similar to a roundabout, however the center of the roundabout is fully traversable. Also known as a mini-\n     * roundabout.\n     * @return {String}\n     */\n    static get TRAVERSABLE_ROUNDABOUT () {\n        return NavigationJunction._MAP.TRAVERSABLE_ROUNDABOUT;\n    }\n\n    /**\n     * A junction where lefts diverge to the right, then curve to the left, converting a left turn to a crossing\n     * maneuver.\n     * @return {String}\n     */\n    static get JUGHANDLE () {\n        return NavigationJunction._MAP.JUGHANDLE;\n    }\n\n    /**\n     * Multiple way intersection that allows traffic to flow based on priority; most commonly right of way and first\n     * in, first out.\n     * @return {String}\n     */\n    static get ALL_WAY_YIELD () {\n        return NavigationJunction._MAP.ALL_WAY_YIELD;\n    }\n\n    /**\n     * A junction designated for traffic turn arounds.\n     * @return {String}\n     */\n    static get TURN_AROUND () {\n        return NavigationJunction._MAP.TURN_AROUND;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return NavigationJunction._valueForKey(key, NavigationJunction._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return NavigationJunction._keyForValue(value, NavigationJunction._MAP);\n    }\n}\n\nNavigationJunction._MAP = Object.freeze({\n    'REGULAR': 'REGULAR',\n    'BIFURCATION': 'BIFURCATION',\n    'MULTI_CARRIAGEWAY': 'MULTI_CARRIAGEWAY',\n    'ROUNDABOUT': 'ROUNDABOUT',\n    'TRAVERSABLE_ROUNDABOUT': 'TRAVERSABLE_ROUNDABOUT',\n    'JUGHANDLE': 'JUGHANDLE',\n    'ALL_WAY_YIELD': 'ALL_WAY_YIELD',\n    'TURN_AROUND': 'TURN_AROUND',\n});\n\nexport { NavigationJunction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} Direction\n * @property {Object} _MAP\n */\nclass Direction extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LEFT () {\n        return Direction._MAP.LEFT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get RIGHT () {\n        return Direction._MAP.RIGHT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return Direction._valueForKey(key, Direction._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return Direction._keyForValue(value, Direction._MAP);\n    }\n}\n\nDirection._MAP = Object.freeze({\n    'LEFT': 'LEFT',\n    'RIGHT': 'RIGHT',\n});\n\nexport { Direction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} NavigationAction\n * @property {Object} _MAP\n */\nclass NavigationAction extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Using this action plus a supplied direction can give the type of turn.\n     * @return {String}\n     */\n    static get TURN () {\n        return NavigationAction._MAP.TURN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get EXIT () {\n        return NavigationAction._MAP.EXIT;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get STAY () {\n        return NavigationAction._MAP.STAY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MERGE () {\n        return NavigationAction._MAP.MERGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FERRY () {\n        return NavigationAction._MAP.FERRY;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CAR_SHUTTLE_TRAIN () {\n        return NavigationAction._MAP.CAR_SHUTTLE_TRAIN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WAYPOINT () {\n        return NavigationAction._MAP.WAYPOINT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return NavigationAction._valueForKey(key, NavigationAction._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return NavigationAction._keyForValue(value, NavigationAction._MAP);\n    }\n}\n\nNavigationAction._MAP = Object.freeze({\n    'TURN': 'TURN',\n    'EXIT': 'EXIT',\n    'STAY': 'STAY',\n    'MERGE': 'MERGE',\n    'FERRY': 'FERRY',\n    'CAR_SHUTTLE_TRAIN': 'CAR_SHUTTLE_TRAIN',\n    'WAYPOINT': 'WAYPOINT',\n});\n\nexport { NavigationAction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Image } from './Image.js';\nimport { DateTime } from './DateTime.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { NavigationJunction } from '../enums/NavigationJunction.js';\nimport { Direction } from '../enums/Direction.js';\nimport { LocationDetails } from './LocationDetails.js';\nimport { NavigationAction } from '../enums/NavigationAction.js';\n\nclass NavigationInstruction extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {LocationDetails} details\n     * @return {NavigationInstruction}\n     */\n    setLocationDetails (details) {\n        this.validateType(LocationDetails, details);\n        this.setParameter(NavigationInstruction.KEY_LOCATION_DETAILS, details);\n        return this;\n    }\n\n    /**\n     * @return {LocationDetails}\n     */\n    getLocationDetails () {\n        return this.getObject(LocationDetails, NavigationInstruction.KEY_LOCATION_DETAILS);\n    }\n\n    /**\n     * @param {NavigationAction} action\n     * @return {NavigationInstruction}\n     */\n    setAction (action) {\n        this.validateType(NavigationAction, action);\n        this.setParameter(NavigationInstruction.KEY_ACTION, action);\n        return this;\n    }\n\n    /**\n     * @return {NavigationAction}\n     */\n    getAction () {\n        return this.getObject(NavigationAction, NavigationInstruction.KEY_ACTION);\n    }\n\n    /**\n     * @param {DateTime} eta\n     * @return {NavigationInstruction}\n     */\n    setEta (eta) {\n        this.validateType(DateTime, eta);\n        this.setParameter(NavigationInstruction.KEY_ETA, eta);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getEta () {\n        return this.getObject(DateTime, NavigationInstruction.KEY_ETA);\n    }\n\n    /**\n     * @param {Number} bearing - The angle at which this instruction takes place. For example, 0 would mean straight,\n     *                           less than 45 is bearing right, greater than 135 is sharp right, between 45 and 135 is a\n     *                           regular right, and 180 is a U-Turn, etc.\n     * @return {NavigationInstruction}\n     */\n    setBearing (bearing) {\n        this.setParameter(NavigationInstruction.KEY_BEARING, bearing);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getBearing () {\n        return this.getParameter(NavigationInstruction.KEY_BEARING);\n    }\n\n    /**\n     * @param {NavigationJunction} type\n     * @return {NavigationInstruction}\n     */\n    setJunctionType (type) {\n        this.validateType(NavigationJunction, type);\n        this.setParameter(NavigationInstruction.KEY_JUNCTION_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {NavigationJunction}\n     */\n    getJunctionType () {\n        return this.getObject(NavigationJunction, NavigationInstruction.KEY_JUNCTION_TYPE);\n    }\n\n    /**\n     * @param {Direction} side - Used to infer which side of the road this instruction takes place. For a U-Turn\n     *                           (action=TURN, bearing=180) this will determine which direction the turn should take\n     *                           place.\n     * @return {NavigationInstruction}\n     */\n    setDrivingSide (side) {\n        this.validateType(Direction, side);\n        this.setParameter(NavigationInstruction.KEY_DRIVING_SIDE, side);\n        return this;\n    }\n\n    /**\n     * @return {Direction}\n     */\n    getDrivingSide () {\n        return this.getObject(Direction, NavigationInstruction.KEY_DRIVING_SIDE);\n    }\n\n    /**\n     * @param {String} details - This is a string representation of this instruction, used to display instructions to\n     *                           the users. This is not intended to be read aloud to the users, see the param prompt in\n     *                           NavigationServiceData for that.\n     * @return {NavigationInstruction}\n     */\n    setDetails (details) {\n        this.setParameter(NavigationInstruction.KEY_DETAILS, details);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getDetails () {\n        return this.getParameter(NavigationInstruction.KEY_DETAILS);\n    }\n\n    /**\n     * @param {Image} image - An image representation of this instruction.\n     * @return {NavigationInstruction}\n     */\n    setImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(NavigationInstruction.KEY_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getImage () {\n        return this.getObject(Image, NavigationInstruction.KEY_IMAGE);\n    }\n}\n\nNavigationInstruction.KEY_LOCATION_DETAILS = 'locationDetails';\nNavigationInstruction.KEY_ACTION = 'action';\nNavigationInstruction.KEY_ETA = 'eta';\nNavigationInstruction.KEY_BEARING = 'bearing';\nNavigationInstruction.KEY_JUNCTION_TYPE = 'junctionType';\nNavigationInstruction.KEY_DRIVING_SIDE = 'drivingSide';\nNavigationInstruction.KEY_DETAILS = 'details';\nNavigationInstruction.KEY_IMAGE = 'image';\n\nexport { NavigationInstruction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { DateTime } from './DateTime.js';\nimport { LocationDetails } from './LocationDetails.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { NavigationInstruction } from './NavigationInstruction.js';\n\n/**\n * This data is related to what a navigation service would provide.\n */\nclass NavigationServiceData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {DateTime} stamp - This is the timestamp of when the data was generated. This is to ensure any time or\n     *                           distance given in the data can accurately be adjusted if necessary.\n     * @return {NavigationServiceData}\n     */\n    setTimeStamp (stamp) {\n        this.validateType(DateTime, stamp);\n        this.setParameter(NavigationServiceData.KEY_TIME_STAMP, stamp);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getTimeStamp () {\n        return this.getObject(DateTime, NavigationServiceData.KEY_TIME_STAMP);\n    }\n\n    /**\n     * @param {LocationDetails} origin\n     * @return {NavigationServiceData}\n     */\n    setOrigin (origin) {\n        this.validateType(LocationDetails, origin);\n        this.setParameter(NavigationServiceData.KEY_ORIGIN, origin);\n        return this;\n    }\n\n    /**\n     * @return {LocationDetails}\n     */\n    getOrigin () {\n        return this.getObject(LocationDetails, NavigationServiceData.KEY_ORIGIN);\n    }\n\n    /**\n     * @param {LocationDetails} destination\n     * @return {NavigationServiceData}\n     */\n    setDestination (destination) {\n        this.validateType(LocationDetails, destination);\n        this.setParameter(NavigationServiceData.KEY_DESTINATION, destination);\n        return this;\n    }\n\n    /**\n     * @return {LocationDetails}\n     */\n    getDestination () {\n        return this.getObject(LocationDetails, NavigationServiceData.KEY_DESTINATION);\n    }\n\n    /**\n     * @param {DateTime} eta\n     * @return {NavigationServiceData}\n     */\n    setDestinationETA (eta) {\n        this.validateType(DateTime, eta);\n        this.setParameter(NavigationServiceData.KEY_DESTINATION_ETA, eta);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getDestinationETA () {\n        return this.getObject(DateTime, NavigationServiceData.KEY_DESTINATION_ETA);\n    }\n\n    /**\n     * @param {NavigationInstruction[]} instructions - This array should be ordered with all remaining instructions. The\n     *                                                 start of this array should always contain the next instruction.\n     * @return {NavigationServiceData}\n     */\n    setInstructions (instructions) {\n        this.validateType(NavigationInstruction, instructions, true);\n        this.setParameter(NavigationServiceData.KEY_INSTRUCTIONS, instructions);\n        return this;\n    }\n\n    /**\n     * @return {NavigationInstruction[]}\n     */\n    getInstructions () {\n        return this.getObject(NavigationInstruction, NavigationServiceData.KEY_INSTRUCTIONS);\n    }\n\n    /**\n     * @param {DateTime} eta\n     * @return {NavigationServiceData}\n     */\n    setNextInstructionETA (eta) {\n        this.validateType(DateTime, eta);\n        this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA, eta);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getNextInstructionETA () {\n        return this.getObject(DateTime, NavigationServiceData.KEY_NEXT_INSTRUCTION_ETA);\n    }\n\n    /**\n     * @param {Number} distance - The distance to this instruction from current location. This should only be updated\n     *                            ever .1 unit of distance. For more accuracy the consumer can use the GPS location of\n     *                            itself and the next instruction.\n     * @return {NavigationServiceData}\n     */\n    setNextInstructionDistance (distance) {\n        this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE, distance);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getNextInstructionDistance () {\n        return this.getParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE);\n    }\n\n    /**\n     * @param {Number} scale - Distance till next maneuver (starting from) from previous maneuver.\n     * @return {NavigationServiceData}\n     */\n    setNextInstructionDistanceScale (scale) {\n        this.setParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE, scale);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getNextInstructionDistanceScale () {\n        return this.getParameter(NavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE);\n    }\n\n    /**\n     * @param {String} prompt - This is a prompt message that should be conveyed to the user through either display or\n     *                          voice (TTS). This param will change often as it should represent the following:\n     *                          approaching instruction, post instruction, alerts that affect the current navigation\n     *                          session, etc.\n     * @return {NavigationServiceData}\n     */\n    setPrompt (prompt) {\n        this.setParameter(NavigationServiceData.KEY_PROMPT, prompt);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPrompt () {\n        return this.getParameter(NavigationServiceData.KEY_PROMPT);\n    }\n}\n\nNavigationServiceData.KEY_TIME_STAMP = 'timeStamp';\nNavigationServiceData.KEY_ORIGIN = 'origin';\nNavigationServiceData.KEY_DESTINATION = 'destination';\nNavigationServiceData.KEY_DESTINATION_ETA = 'destinationETA';\nNavigationServiceData.KEY_INSTRUCTIONS = 'instructions';\nNavigationServiceData.KEY_NEXT_INSTRUCTION_ETA = 'nextInstructionETA';\nNavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE = 'nextInstructionDistance';\nNavigationServiceData.KEY_NEXT_INSTRUCTION_DISTANCE_SCALE = 'nextInstructionDistanceScale';\nNavigationServiceData.KEY_PROMPT = 'prompt';\n\nexport { NavigationServiceData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} MediaType\n * @property {Object} _MAP\n */\nclass MediaType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MUSIC () {\n        return MediaType._MAP.MUSIC;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PODCAST () {\n        return MediaType._MAP.PODCAST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIOBOOK () {\n        return MediaType._MAP.AUDIOBOOK;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get OTHER () {\n        return MediaType._MAP.OTHER;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MediaType._valueForKey(key, MediaType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MediaType._keyForValue(value, MediaType._MAP);\n    }\n}\n\nMediaType._MAP = Object.freeze({\n    'MUSIC': 'MUSIC',\n    'PODCAST': 'PODCAST',\n    'AUDIOBOOK': 'AUDIOBOOK',\n    'OTHER': 'OTHER',\n});\n\nexport { MediaType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { Image } from './Image.js';\nimport { MediaType } from '../enums/MediaType.js';\n\n/**\n * This data is related to what a media service should provide\n */\nclass MediaServiceData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {MediaType} type - The type of the currently playing or paused track.\n     * @return {MediaServiceData}\n     */\n    setMediaType (type) {\n        this.validateType(MediaType, type);\n        this.setParameter(MediaServiceData.KEY_MEDIA_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {MediaType}\n     */\n    getMediaType () {\n        return this.getObject(MediaType, MediaServiceData.KEY_MEDIA_TYPE);\n    }\n\n    /**\n     * @param {String} title - Music: The name of the current track Podcast: The name of the current episode Audiobook:\n     *                         The name of the current chapter\n     * @return {MediaServiceData}\n     */\n    setMediaTitle (title) {\n        this.setParameter(MediaServiceData.KEY_MEDIA_TITLE, title);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMediaTitle () {\n        return this.getParameter(MediaServiceData.KEY_MEDIA_TITLE);\n    }\n\n    /**\n     * @param {String} artist - Music: The name of the current album artist Podcast: The provider of the podcast (hosts,\n     *                          network, company) Audiobook: The book author's name\n     * @return {MediaServiceData}\n     */\n    setMediaArtist (artist) {\n        this.setParameter(MediaServiceData.KEY_MEDIA_ARTIST, artist);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMediaArtist () {\n        return this.getParameter(MediaServiceData.KEY_MEDIA_ARTIST);\n    }\n\n    /**\n     * @param {String} album - Music: The name of the current album Podcast: The name of the current podcast show\n     *                         Audiobook: The name of the current book\n     * @return {MediaServiceData}\n     */\n    setMediaAlbum (album) {\n        this.setParameter(MediaServiceData.KEY_MEDIA_ALBUM, album);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getMediaAlbum () {\n        return this.getParameter(MediaServiceData.KEY_MEDIA_ALBUM);\n    }\n\n    /**\n     * @param {String} name - Music: The name of the playlist or radio station, if the user is playing from a playlist,\n     *                        otherwise, Null Podcast: The name of the playlist, if the user is playing from a playlist,\n     *                        otherwise, Null Audiobook: Likely not applicable, possibly a collection or \"playlist\" of\n     *                        books\n     * @return {MediaServiceData}\n     */\n    setPlaylistName (name) {\n        this.setParameter(MediaServiceData.KEY_PLAYLIST_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPlaylistName () {\n        return this.getParameter(MediaServiceData.KEY_PLAYLIST_NAME);\n    }\n\n    /**\n     * @param {Boolean} explicit - Whether or not the content currently playing (e.g. the track, episode, or book)\n     *                             contains explicit content\n     * @return {MediaServiceData}\n     */\n    setIsExplicit (explicit) {\n        this.setParameter(MediaServiceData.KEY_IS_EXPLICIT, explicit);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getIsExplicit () {\n        return this.getParameter(MediaServiceData.KEY_IS_EXPLICIT);\n    }\n\n    /**\n     * @param {Number} progress - Music: The current progress of the track in seconds Podcast: The current progress of\n     *                            the episode in seconds Audiobook: The current progress of the current segment (e.g.\n     *                            the chapter) in seconds\n     * @return {MediaServiceData}\n     */\n    setTrackPlaybackProgress (progress) {\n        this.setParameter(MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS, progress);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTrackPlaybackProgress () {\n        return this.getParameter(MediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS);\n    }\n\n    /**\n     * @param {Number} duration - Music: The total duration of the track in seconds Podcast: The total duration of the\n     *                            episode in seconds Audiobook: The total duration of the current segment (e.g. the\n     *                            chapter) in seconds\n     * @return {MediaServiceData}\n     */\n    setTrackPlaybackDuration (duration) {\n        this.setParameter(MediaServiceData.KEY_TRACK_PLAYBACK_DURATION, duration);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTrackPlaybackDuration () {\n        return this.getParameter(MediaServiceData.KEY_TRACK_PLAYBACK_DURATION);\n    }\n\n    /**\n     * @param {Number} progress - Music: The current progress of the playback queue in seconds Podcast: The current\n     *                            progress of the playback queue in seconds Audiobook: The current progress of the\n     *                            playback queue (e.g. the book) in seconds\n     * @return {MediaServiceData}\n     */\n    setQueuePlaybackProgress (progress) {\n        this.setParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS, progress);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getQueuePlaybackProgress () {\n        return this.getParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS);\n    }\n\n    /**\n     * @param {Number} duration - Music: The total duration of the playback queue in seconds Podcast: The total duration\n     *                            of the playback queue in seconds Audiobook: The total duration of the playback queue\n     *                            (e.g. the book) in seconds\n     * @return {MediaServiceData}\n     */\n    setQueuePlaybackDuration (duration) {\n        this.setParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION, duration);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getQueuePlaybackDuration () {\n        return this.getParameter(MediaServiceData.KEY_QUEUE_PLAYBACK_DURATION);\n    }\n\n    /**\n     * @param {Number} number - Music: The current number (1 based) of the track in the playback queue Podcast: The\n     *                          current number (1 based) of the episode in the playback queue Audiobook: The current\n     *                          number (1 based) of the episode in the playback queue (e.g. the chapter number in the\n     *                          book)\n     * @return {MediaServiceData}\n     */\n    setQueueCurrentTrackNumber (number) {\n        this.setParameter(MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER, number);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getQueueCurrentTrackNumber () {\n        return this.getParameter(MediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER);\n    }\n\n    /**\n     * @param {Number} count - Music: The total number of tracks in the playback queue Podcast: The total number of\n     *                         episodes in the playback queue Audiobook: The total number of sections in the playback\n     *                         queue (e.g. the number of chapters in the book)\n     * @return {MediaServiceData}\n     */\n    setQueueTotalTrackCount (count) {\n        this.setParameter(MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT, count);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getQueueTotalTrackCount () {\n        return this.getParameter(MediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT);\n    }\n\n    /**\n     * @param {Image} image - Music: The album art of the current track Podcast: The podcast or chapter artwork of the\n     *                        current podcast episode Audiobook: The book or chapter artwork of the current audiobook\n     * @return {MediaServiceData}\n     */\n    setMediaImage (image) {\n        this.validateType(Image, image);\n        this.setParameter(MediaServiceData.KEY_MEDIA_IMAGE, image);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getMediaImage () {\n        return this.getObject(Image, MediaServiceData.KEY_MEDIA_IMAGE);\n    }\n}\n\nMediaServiceData.KEY_MEDIA_TYPE = 'mediaType';\nMediaServiceData.KEY_MEDIA_TITLE = 'mediaTitle';\nMediaServiceData.KEY_MEDIA_ARTIST = 'mediaArtist';\nMediaServiceData.KEY_MEDIA_ALBUM = 'mediaAlbum';\nMediaServiceData.KEY_PLAYLIST_NAME = 'playlistName';\nMediaServiceData.KEY_IS_EXPLICIT = 'isExplicit';\nMediaServiceData.KEY_TRACK_PLAYBACK_PROGRESS = 'trackPlaybackProgress';\nMediaServiceData.KEY_TRACK_PLAYBACK_DURATION = 'trackPlaybackDuration';\nMediaServiceData.KEY_QUEUE_PLAYBACK_PROGRESS = 'queuePlaybackProgress';\nMediaServiceData.KEY_QUEUE_PLAYBACK_DURATION = 'queuePlaybackDuration';\nMediaServiceData.KEY_QUEUE_CURRENT_TRACK_NUMBER = 'queueCurrentTrackNumber';\nMediaServiceData.KEY_QUEUE_TOTAL_TRACK_COUNT = 'queueTotalTrackCount';\nMediaServiceData.KEY_MEDIA_IMAGE = 'mediaImage';\n\nexport { MediaServiceData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Temperature } from './Temperature.js';\nimport { Image } from './Image.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { DateTime } from './DateTime.js';\n\nclass WeatherData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Temperature} temperature\n     * @return {WeatherData}\n     */\n    setCurrentTemperature (temperature) {\n        this.validateType(Temperature, temperature);\n        this.setParameter(WeatherData.KEY_CURRENT_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getCurrentTemperature () {\n        return this.getObject(Temperature, WeatherData.KEY_CURRENT_TEMPERATURE);\n    }\n\n    /**\n     * @param {Temperature} high\n     * @return {WeatherData}\n     */\n    setTemperatureHigh (high) {\n        this.validateType(Temperature, high);\n        this.setParameter(WeatherData.KEY_TEMPERATURE_HIGH, high);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getTemperatureHigh () {\n        return this.getObject(Temperature, WeatherData.KEY_TEMPERATURE_HIGH);\n    }\n\n    /**\n     * @param {Temperature} low\n     * @return {WeatherData}\n     */\n    setTemperatureLow (low) {\n        this.validateType(Temperature, low);\n        this.setParameter(WeatherData.KEY_TEMPERATURE_LOW, low);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getTemperatureLow () {\n        return this.getObject(Temperature, WeatherData.KEY_TEMPERATURE_LOW);\n    }\n\n    /**\n     * @param {Temperature} temperature\n     * @return {WeatherData}\n     */\n    setApparentTemperature (temperature) {\n        this.validateType(Temperature, temperature);\n        this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getApparentTemperature () {\n        return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE);\n    }\n\n    /**\n     * @param {Temperature} high\n     * @return {WeatherData}\n     */\n    setApparentTemperatureHigh (high) {\n        this.validateType(Temperature, high);\n        this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE_HIGH, high);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getApparentTemperatureHigh () {\n        return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE_HIGH);\n    }\n\n    /**\n     * @param {Temperature} low\n     * @return {WeatherData}\n     */\n    setApparentTemperatureLow (low) {\n        this.validateType(Temperature, low);\n        this.setParameter(WeatherData.KEY_APPARENT_TEMPERATURE_LOW, low);\n        return this;\n    }\n\n    /**\n     * @return {Temperature}\n     */\n    getApparentTemperatureLow () {\n        return this.getObject(Temperature, WeatherData.KEY_APPARENT_TEMPERATURE_LOW);\n    }\n\n    /**\n     * @param {String} summary\n     * @return {WeatherData}\n     */\n    setWeatherSummary (summary) {\n        this.setParameter(WeatherData.KEY_WEATHER_SUMMARY, summary);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getWeatherSummary () {\n        return this.getParameter(WeatherData.KEY_WEATHER_SUMMARY);\n    }\n\n    /**\n     * @param {DateTime} time\n     * @return {WeatherData}\n     */\n    setTime (time) {\n        this.validateType(DateTime, time);\n        this.setParameter(WeatherData.KEY_TIME, time);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getTime () {\n        return this.getObject(DateTime, WeatherData.KEY_TIME);\n    }\n\n    /**\n     * @param {Number} humidity - 0 to 1, percentage humidity\n     * @return {WeatherData}\n     */\n    setHumidity (humidity) {\n        this.setParameter(WeatherData.KEY_HUMIDITY, humidity);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getHumidity () {\n        return this.getParameter(WeatherData.KEY_HUMIDITY);\n    }\n\n    /**\n     * @param {Number} cover - 0 to 1, percentage cloud cover\n     * @return {WeatherData}\n     */\n    setCloudCover (cover) {\n        this.setParameter(WeatherData.KEY_CLOUD_COVER, cover);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCloudCover () {\n        return this.getParameter(WeatherData.KEY_CLOUD_COVER);\n    }\n\n    /**\n     * @param {Number} phase - 0 to 1, percentage of the moon seen, e.g. 0 = no moon, 0.25 = quarter moon\n     * @return {WeatherData}\n     */\n    setMoonPhase (phase) {\n        this.setParameter(WeatherData.KEY_MOON_PHASE, phase);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getMoonPhase () {\n        return this.getParameter(WeatherData.KEY_MOON_PHASE);\n    }\n\n    /**\n     * @param {Number} bearing - In degrees, true north at 0 degrees\n     * @return {WeatherData}\n     */\n    setWindBearing (bearing) {\n        this.setParameter(WeatherData.KEY_WIND_BEARING, bearing);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindBearing () {\n        return this.getParameter(WeatherData.KEY_WIND_BEARING);\n    }\n\n    /**\n     * @param {Number} gust - km/hr\n     * @return {WeatherData}\n     */\n    setWindGust (gust) {\n        this.setParameter(WeatherData.KEY_WIND_GUST, gust);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindGust () {\n        return this.getParameter(WeatherData.KEY_WIND_GUST);\n    }\n\n    /**\n     * @param {Number} speed - km/hr\n     * @return {WeatherData}\n     */\n    setWindSpeed (speed) {\n        this.setParameter(WeatherData.KEY_WIND_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindSpeed () {\n        return this.getParameter(WeatherData.KEY_WIND_SPEED);\n    }\n\n    /**\n     * @param {Number} bearing - In degrees, true north at 0 degrees\n     * @return {WeatherData}\n     */\n    setNearestStormBearing (bearing) {\n        this.setParameter(WeatherData.KEY_NEAREST_STORM_BEARING, bearing);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getNearestStormBearing () {\n        return this.getParameter(WeatherData.KEY_NEAREST_STORM_BEARING);\n    }\n\n    /**\n     * @param {Number} distance - In km\n     * @return {WeatherData}\n     */\n    setNearestStormDistance (distance) {\n        this.setParameter(WeatherData.KEY_NEAREST_STORM_DISTANCE, distance);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getNearestStormDistance () {\n        return this.getParameter(WeatherData.KEY_NEAREST_STORM_DISTANCE);\n    }\n\n    /**\n     * @param {Number} accumulation - cm\n     * @return {WeatherData}\n     */\n    setPrecipAccumulation (accumulation) {\n        this.setParameter(WeatherData.KEY_PRECIP_ACCUMULATION, accumulation);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPrecipAccumulation () {\n        return this.getParameter(WeatherData.KEY_PRECIP_ACCUMULATION);\n    }\n\n    /**\n     * @param {Number} intensity - cm of water per hour\n     * @return {WeatherData}\n     */\n    setPrecipIntensity (intensity) {\n        this.setParameter(WeatherData.KEY_PRECIP_INTENSITY, intensity);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPrecipIntensity () {\n        return this.getParameter(WeatherData.KEY_PRECIP_INTENSITY);\n    }\n\n    /**\n     * @param {Number} probability - 0 to 1, percentage chance\n     * @return {WeatherData}\n     */\n    setPrecipProbability (probability) {\n        this.setParameter(WeatherData.KEY_PRECIP_PROBABILITY, probability);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getPrecipProbability () {\n        return this.getParameter(WeatherData.KEY_PRECIP_PROBABILITY);\n    }\n\n    /**\n     * @param {String} type - e.g. \"rain\", \"snow\", \"sleet\", \"hail\"\n     * @return {WeatherData}\n     */\n    setPrecipType (type) {\n        this.setParameter(WeatherData.KEY_PRECIP_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getPrecipType () {\n        return this.getParameter(WeatherData.KEY_PRECIP_TYPE);\n    }\n\n    /**\n     * @param {Number} visibility - In km\n     * @return {WeatherData}\n     */\n    setVisibility (visibility) {\n        this.setParameter(WeatherData.KEY_VISIBILITY, visibility);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getVisibility () {\n        return this.getParameter(WeatherData.KEY_VISIBILITY);\n    }\n\n    /**\n     * @param {Image} icon\n     * @return {WeatherData}\n     */\n    setWeatherIcon (icon) {\n        this.validateType(Image, icon);\n        this.setParameter(WeatherData.KEY_WEATHER_ICON, icon);\n        return this;\n    }\n\n    /**\n     * @return {Image}\n     */\n    getWeatherIcon () {\n        return this.getObject(Image, WeatherData.KEY_WEATHER_ICON);\n    }\n}\n\nWeatherData.KEY_CURRENT_TEMPERATURE = 'currentTemperature';\nWeatherData.KEY_TEMPERATURE_HIGH = 'temperatureHigh';\nWeatherData.KEY_TEMPERATURE_LOW = 'temperatureLow';\nWeatherData.KEY_APPARENT_TEMPERATURE = 'apparentTemperature';\nWeatherData.KEY_APPARENT_TEMPERATURE_HIGH = 'apparentTemperatureHigh';\nWeatherData.KEY_APPARENT_TEMPERATURE_LOW = 'apparentTemperatureLow';\nWeatherData.KEY_WEATHER_SUMMARY = 'weatherSummary';\nWeatherData.KEY_TIME = 'time';\nWeatherData.KEY_HUMIDITY = 'humidity';\nWeatherData.KEY_CLOUD_COVER = 'cloudCover';\nWeatherData.KEY_MOON_PHASE = 'moonPhase';\nWeatherData.KEY_WIND_BEARING = 'windBearing';\nWeatherData.KEY_WIND_GUST = 'windGust';\nWeatherData.KEY_WIND_SPEED = 'windSpeed';\nWeatherData.KEY_NEAREST_STORM_BEARING = 'nearestStormBearing';\nWeatherData.KEY_NEAREST_STORM_DISTANCE = 'nearestStormDistance';\nWeatherData.KEY_PRECIP_ACCUMULATION = 'precipAccumulation';\nWeatherData.KEY_PRECIP_INTENSITY = 'precipIntensity';\nWeatherData.KEY_PRECIP_PROBABILITY = 'precipProbability';\nWeatherData.KEY_PRECIP_TYPE = 'precipType';\nWeatherData.KEY_VISIBILITY = 'visibility';\nWeatherData.KEY_WEATHER_ICON = 'weatherIcon';\n\nexport { WeatherData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { DateTime } from './DateTime.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass WeatherAlert extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} title\n     * @return {WeatherAlert}\n     */\n    setTitle (title) {\n        this.setParameter(WeatherAlert.KEY_TITLE, title);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getTitle () {\n        return this.getParameter(WeatherAlert.KEY_TITLE);\n    }\n\n    /**\n     * @param {String} summary\n     * @return {WeatherAlert}\n     */\n    setSummary (summary) {\n        this.setParameter(WeatherAlert.KEY_SUMMARY, summary);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSummary () {\n        return this.getParameter(WeatherAlert.KEY_SUMMARY);\n    }\n\n    /**\n     * @param {DateTime} expires\n     * @return {WeatherAlert}\n     */\n    setExpires (expires) {\n        this.validateType(DateTime, expires);\n        this.setParameter(WeatherAlert.KEY_EXPIRES, expires);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getExpires () {\n        return this.getObject(DateTime, WeatherAlert.KEY_EXPIRES);\n    }\n\n    /**\n     * @param {String[]} regions\n     * @return {WeatherAlert}\n     */\n    setRegions (regions) {\n        this.setParameter(WeatherAlert.KEY_REGIONS, regions);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getRegions () {\n        return this.getParameter(WeatherAlert.KEY_REGIONS);\n    }\n\n    /**\n     * @param {String} severity\n     * @return {WeatherAlert}\n     */\n    setSeverity (severity) {\n        this.setParameter(WeatherAlert.KEY_SEVERITY, severity);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getSeverity () {\n        return this.getParameter(WeatherAlert.KEY_SEVERITY);\n    }\n\n    /**\n     * @param {DateTime} issued\n     * @return {WeatherAlert}\n     */\n    setTimeIssued (issued) {\n        this.validateType(DateTime, issued);\n        this.setParameter(WeatherAlert.KEY_TIME_ISSUED, issued);\n        return this;\n    }\n\n    /**\n     * @return {DateTime}\n     */\n    getTimeIssued () {\n        return this.getObject(DateTime, WeatherAlert.KEY_TIME_ISSUED);\n    }\n}\n\nWeatherAlert.KEY_TITLE = 'title';\nWeatherAlert.KEY_SUMMARY = 'summary';\nWeatherAlert.KEY_EXPIRES = 'expires';\nWeatherAlert.KEY_REGIONS = 'regions';\nWeatherAlert.KEY_SEVERITY = 'severity';\nWeatherAlert.KEY_TIME_ISSUED = 'timeIssued';\n\nexport { WeatherAlert };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { WeatherData } from './WeatherData.js';\nimport { LocationDetails } from './LocationDetails.js';\nimport { RpcStruct } from '../RpcStruct.js';\nimport { WeatherAlert } from './WeatherAlert.js';\n\n/**\n * This data is related to what a weather service would provide\n */\nclass WeatherServiceData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {LocationDetails} location\n     * @return {WeatherServiceData}\n     */\n    setLocation (location) {\n        this.validateType(LocationDetails, location);\n        this.setParameter(WeatherServiceData.KEY_LOCATION, location);\n        return this;\n    }\n\n    /**\n     * @return {LocationDetails}\n     */\n    getLocation () {\n        return this.getObject(LocationDetails, WeatherServiceData.KEY_LOCATION);\n    }\n\n    /**\n     * @param {WeatherData} forecast\n     * @return {WeatherServiceData}\n     */\n    setCurrentForecast (forecast) {\n        this.validateType(WeatherData, forecast);\n        this.setParameter(WeatherServiceData.KEY_CURRENT_FORECAST, forecast);\n        return this;\n    }\n\n    /**\n     * @return {WeatherData}\n     */\n    getCurrentForecast () {\n        return this.getObject(WeatherData, WeatherServiceData.KEY_CURRENT_FORECAST);\n    }\n\n    /**\n     * @param {WeatherData[]} forecast\n     * @return {WeatherServiceData}\n     */\n    setMinuteForecast (forecast) {\n        this.validateType(WeatherData, forecast, true);\n        this.setParameter(WeatherServiceData.KEY_MINUTE_FORECAST, forecast);\n        return this;\n    }\n\n    /**\n     * @return {WeatherData[]}\n     */\n    getMinuteForecast () {\n        return this.getObject(WeatherData, WeatherServiceData.KEY_MINUTE_FORECAST);\n    }\n\n    /**\n     * @param {WeatherData[]} forecast\n     * @return {WeatherServiceData}\n     */\n    setHourlyForecast (forecast) {\n        this.validateType(WeatherData, forecast, true);\n        this.setParameter(WeatherServiceData.KEY_HOURLY_FORECAST, forecast);\n        return this;\n    }\n\n    /**\n     * @return {WeatherData[]}\n     */\n    getHourlyForecast () {\n        return this.getObject(WeatherData, WeatherServiceData.KEY_HOURLY_FORECAST);\n    }\n\n    /**\n     * @param {WeatherData[]} forecast\n     * @return {WeatherServiceData}\n     */\n    setMultidayForecast (forecast) {\n        this.validateType(WeatherData, forecast, true);\n        this.setParameter(WeatherServiceData.KEY_MULTIDAY_FORECAST, forecast);\n        return this;\n    }\n\n    /**\n     * @return {WeatherData[]}\n     */\n    getMultidayForecast () {\n        return this.getObject(WeatherData, WeatherServiceData.KEY_MULTIDAY_FORECAST);\n    }\n\n    /**\n     * @param {WeatherAlert[]} alerts - This array should be ordered with the first object being the current day\n     * @return {WeatherServiceData}\n     */\n    setAlerts (alerts) {\n        this.validateType(WeatherAlert, alerts, true);\n        this.setParameter(WeatherServiceData.KEY_ALERTS, alerts);\n        return this;\n    }\n\n    /**\n     * @return {WeatherAlert[]}\n     */\n    getAlerts () {\n        return this.getObject(WeatherAlert, WeatherServiceData.KEY_ALERTS);\n    }\n}\n\nWeatherServiceData.KEY_LOCATION = 'location';\nWeatherServiceData.KEY_CURRENT_FORECAST = 'currentForecast';\nWeatherServiceData.KEY_MINUTE_FORECAST = 'minuteForecast';\nWeatherServiceData.KEY_HOURLY_FORECAST = 'hourlyForecast';\nWeatherServiceData.KEY_MULTIDAY_FORECAST = 'multidayForecast';\nWeatherServiceData.KEY_ALERTS = 'alerts';\n\nexport { WeatherServiceData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { NavigationServiceData } from './NavigationServiceData.js';\nimport { MediaServiceData } from './MediaServiceData.js';\nimport { WeatherServiceData } from './WeatherServiceData.js';\n\n/**\n * Contains all the current data of the app service. The serviceType will link to which of the service data objects are\n * included in this object (e.g. if the service type is MEDIA, the mediaServiceData param should be included).\n */\nclass AppServiceData extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} type - The type of service that is to be offered by this app. See AppServiceType for known enum\n     *                        equivalent types. Parameter is a string to allow for new service types to be used by apps\n     *                        on older versions of SDL Core.\n     * @return {AppServiceData}\n     */\n    setServiceType (type) {\n        this.setParameter(AppServiceData.KEY_SERVICE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceType () {\n        return this.getParameter(AppServiceData.KEY_SERVICE_TYPE);\n    }\n\n    /**\n     * @param {String} id\n     * @return {AppServiceData}\n     */\n    setServiceID (id) {\n        this.setParameter(AppServiceData.KEY_SERVICE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceID () {\n        return this.getParameter(AppServiceData.KEY_SERVICE_ID);\n    }\n\n    /**\n     * @param {MediaServiceData} data - This data is related to what a media service should provide\n     * @return {AppServiceData}\n     */\n    setMediaServiceData (data) {\n        this.validateType(MediaServiceData, data);\n        this.setParameter(AppServiceData.KEY_MEDIA_SERVICE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {MediaServiceData}\n     */\n    getMediaServiceData () {\n        return this.getObject(MediaServiceData, AppServiceData.KEY_MEDIA_SERVICE_DATA);\n    }\n\n    /**\n     * @param {WeatherServiceData} data - This data is related to what a weather service would provide\n     * @return {AppServiceData}\n     */\n    setWeatherServiceData (data) {\n        this.validateType(WeatherServiceData, data);\n        this.setParameter(AppServiceData.KEY_WEATHER_SERVICE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {WeatherServiceData}\n     */\n    getWeatherServiceData () {\n        return this.getObject(WeatherServiceData, AppServiceData.KEY_WEATHER_SERVICE_DATA);\n    }\n\n    /**\n     * @param {NavigationServiceData} data - This data is related to what a navigation service would provide.\n     * @return {AppServiceData}\n     */\n    setNavigationServiceData (data) {\n        this.validateType(NavigationServiceData, data);\n        this.setParameter(AppServiceData.KEY_NAVIGATION_SERVICE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {NavigationServiceData}\n     */\n    getNavigationServiceData () {\n        return this.getObject(NavigationServiceData, AppServiceData.KEY_NAVIGATION_SERVICE_DATA);\n    }\n}\n\nAppServiceData.KEY_SERVICE_TYPE = 'serviceType';\nAppServiceData.KEY_SERVICE_ID = 'serviceID';\nAppServiceData.KEY_MEDIA_SERVICE_DATA = 'mediaServiceData';\nAppServiceData.KEY_WEATHER_SERVICE_DATA = 'weatherServiceData';\nAppServiceData.KEY_NAVIGATION_SERVICE_DATA = 'navigationServiceData';\n\nexport { AppServiceData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { AppServiceData } from '../structs/AppServiceData.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * This response includes the data that was requested from the specific service\n */\nclass GetAppServiceDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.GetAppServiceData);\n    }\n\n    /**\n     * @param {AppServiceData} data - Contains all the current data of the app service. The serviceType will link to\n     *                                which of the service data objects are included in this object (e.g. if the service\n     *                                type is MEDIA, the mediaServiceData param should be included).\n     * @return {GetAppServiceDataResponse}\n     */\n    setServiceData (data) {\n        this.validateType(AppServiceData, data);\n        this.setParameter(GetAppServiceDataResponse.KEY_SERVICE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {AppServiceData}\n     */\n    getServiceData () {\n        return this.getObject(AppServiceData, GetAppServiceDataResponse.KEY_SERVICE_DATA);\n    }\n}\n\nGetAppServiceDataResponse.KEY_SERVICE_DATA = 'serviceData';\n\nexport { GetAppServiceDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\nclass PerformAppServiceInteraction extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PerformAppServiceInteraction);\n    }\n\n    /**\n     * @param {String} uri - Fully qualified URI based on a predetermined scheme provided by the app service. SDL makes\n     *                       no guarantee that this URI is correct.\n     * @return {PerformAppServiceInteraction}\n     */\n    setServiceUri (uri) {\n        this.setParameter(PerformAppServiceInteraction.KEY_SERVICE_URI, uri);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceUri () {\n        return this.getParameter(PerformAppServiceInteraction.KEY_SERVICE_URI);\n    }\n\n    /**\n     * @param {String} id - The service ID that the app consumer wishes to send this URI.\n     * @return {PerformAppServiceInteraction}\n     */\n    setServiceID (id) {\n        this.setParameter(PerformAppServiceInteraction.KEY_SERVICE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceID () {\n        return this.getParameter(PerformAppServiceInteraction.KEY_SERVICE_ID);\n    }\n\n    /**\n     * @param {String} app - This string is the appID of the app requesting the app service provider take the specific\n     *                       action.\n     * @return {PerformAppServiceInteraction}\n     */\n    setOriginApp (app) {\n        this.setParameter(PerformAppServiceInteraction.KEY_ORIGIN_APP, app);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getOriginApp () {\n        return this.getParameter(PerformAppServiceInteraction.KEY_ORIGIN_APP);\n    }\n\n    /**\n     * @param {Boolean} active - This flag signals the requesting consumer would like this service to become the active\n     *                           primary service of the destination's type.\n     * @return {PerformAppServiceInteraction}\n     */\n    setRequestServiceActive (active) {\n        this.setParameter(PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE, active);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRequestServiceActive () {\n        return this.getParameter(PerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE);\n    }\n}\n\nPerformAppServiceInteraction.KEY_SERVICE_URI = 'serviceUri';\nPerformAppServiceInteraction.KEY_SERVICE_ID = 'serviceID';\nPerformAppServiceInteraction.KEY_ORIGIN_APP = 'originApp';\nPerformAppServiceInteraction.KEY_REQUEST_SERVICE_ACTIVE = 'requestServiceActive';\n\nexport { PerformAppServiceInteraction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass PerformAppServiceInteractionResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.PerformAppServiceInteraction);\n    }\n\n    /**\n     * @param {String} result - The service can provide specific result strings to the consumer through this param.\n     * @return {PerformAppServiceInteractionResponse}\n     */\n    setServiceSpecificResult (result) {\n        this.setParameter(PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT, result);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getServiceSpecificResult () {\n        return this.getParameter(PerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT);\n    }\n}\n\nPerformAppServiceInteractionResponse.KEY_SERVICE_SPECIFIC_RESULT = 'serviceSpecificResult';\n\nexport { PerformAppServiceInteractionResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Close an active interaction on the HMI.\n */\nclass CancelInteraction extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CancelInteraction);\n    }\n\n    /**\n     * @param {Number} id - The ID of the specific interaction you want to dismiss. If not set, the most recent of the\n     *                      RPC type set in functionID will be dismissed.\n     * @return {CancelInteraction}\n     */\n    setCancelID (id) {\n        this.setParameter(CancelInteraction.KEY_CANCEL_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCancelID () {\n        return this.getParameter(CancelInteraction.KEY_CANCEL_ID);\n    }\n\n    /**\n     * @param {Number} id - The ID of the type of interaction the developer wants to dismiss. Only values 10,\n     *                      (PerformInteractionID), 12 (AlertID), 25 (ScrollableMessageID), and 26 (SliderID) are\n     *                      permitted.\n     * @return {CancelInteraction}\n     */\n    setFunctionID (id) {\n        this.setParameter(CancelInteraction.KEY_FUNCTION_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFunctionID () {\n        return this.getParameter(CancelInteraction.KEY_FUNCTION_ID);\n    }\n}\n\nCancelInteraction.KEY_CANCEL_ID = 'cancelID';\nCancelInteraction.KEY_FUNCTION_ID = 'functionID';\n\nexport { CancelInteraction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\n/**\n * If no applicable request can be dismissed, the result will be IGNORED.\n */\nclass CancelInteractionResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CancelInteraction);\n    }\n}\n\n\nexport { CancelInteractionResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Request from the application to exit the foreground and enter HMI_NONE.\n */\nclass CloseApplication extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CloseApplication);\n    }\n}\n\n\nexport { CloseApplication };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass CloseApplicationResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.CloseApplication);\n    }\n}\n\n\nexport { CloseApplicationResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes possible contexts an app's HMI might be in. Communicated to whichever app is in HMI FULL,\n * except Alert.\n * @typedef {Enum} SystemContext\n * @property {Object} _MAP\n */\nclass SystemContext extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The app's persistent display (whether media/non-media/navigation) is fully visible onscreen.\n     * @return {String}\n     */\n    static get SYSCTXT_MAIN () {\n        return SystemContext._MAP.SYSCTXT_MAIN;\n    }\n\n    /**\n     * The system is currently in a VR session (with whatever dedicated VR screen being overlaid onscreen).\n     * @return {String}\n     */\n    static get SYSCTXT_VRSESSION () {\n        return SystemContext._MAP.SYSCTXT_VRSESSION;\n    }\n\n    /**\n     * The system is currently displaying an in-App menu onscreen.\n     * @return {String}\n     */\n    static get SYSCTXT_MENU () {\n        return SystemContext._MAP.SYSCTXT_MENU;\n    }\n\n    /**\n     * The app's display HMI is currently being obscured by either a system or other app's overlay.\n     * @return {String}\n     */\n    static get SYSCTXT_HMI_OBSCURED () {\n        return SystemContext._MAP.SYSCTXT_HMI_OBSCURED;\n    }\n\n    /**\n     * Broadcast only to whichever app has an alert currently being displayed.\n     * @return {String}\n     */\n    static get SYSCTXT_ALERT () {\n        return SystemContext._MAP.SYSCTXT_ALERT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return SystemContext._valueForKey(key, SystemContext._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return SystemContext._keyForValue(value, SystemContext._MAP);\n    }\n}\n\nSystemContext._MAP = Object.freeze({\n    'SYSCTXT_MAIN': 'MAIN',\n    'SYSCTXT_VRSESSION': 'VRSESSION',\n    'SYSCTXT_MENU': 'MENU',\n    'SYSCTXT_HMI_OBSCURED': 'HMI_OBSCURED',\n    'SYSCTXT_ALERT': 'ALERT',\n});\n\nexport { SystemContext };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcMessage } from './RpcMessage.js';\nimport { RpcType } from './enums/RpcType.js';\n\nclass RpcNotification extends RpcMessage {\n    /**\n    * @constructor\n    */\n    constructor (store) {\n        super(store);\n        this.setRPCType(RpcType.NOTIFICATION);\n    }\n}\n\nexport { RpcNotification };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes possible states of audio streaming.\n * @typedef {Enum} AudioStreamingState\n * @property {Object} _MAP\n */\nclass AudioStreamingState extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get AUDIBLE () {\n        return AudioStreamingState._MAP.AUDIBLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ATTENUATED () {\n        return AudioStreamingState._MAP.ATTENUATED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NOT_AUDIBLE () {\n        return AudioStreamingState._MAP.NOT_AUDIBLE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return AudioStreamingState._valueForKey(key, AudioStreamingState._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return AudioStreamingState._keyForValue(value, AudioStreamingState._MAP);\n    }\n}\n\nAudioStreamingState._MAP = Object.freeze({\n    'AUDIBLE': 'AUDIBLE',\n    'ATTENUATED': 'ATTENUATED',\n    'NOT_AUDIBLE': 'NOT_AUDIBLE',\n});\n\nexport { AudioStreamingState };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes current levels of HMI.\n * @typedef {Enum} HMILevel\n * @property {Object} _MAP\n */\nclass HMILevel extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_FULL () {\n        return HMILevel._MAP.HMI_FULL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_LIMITED () {\n        return HMILevel._MAP.HMI_LIMITED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_BACKGROUND () {\n        return HMILevel._MAP.HMI_BACKGROUND;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get HMI_NONE () {\n        return HMILevel._MAP.HMI_NONE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return HMILevel._valueForKey(key, HMILevel._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return HMILevel._keyForValue(value, HMILevel._MAP);\n    }\n}\n\nHMILevel._MAP = Object.freeze({\n    'HMI_FULL': 'FULL',\n    'HMI_LIMITED': 'LIMITED',\n    'HMI_BACKGROUND': 'BACKGROUND',\n    'HMI_NONE': 'NONE',\n});\n\nexport { HMILevel };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes possible states of video streaming.\n * @typedef {Enum} VideoStreamingState\n * @property {Object} _MAP\n */\nclass VideoStreamingState extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get STREAMABLE () {\n        return VideoStreamingState._MAP.STREAMABLE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NOT_STREAMABLE () {\n        return VideoStreamingState._MAP.NOT_STREAMABLE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VideoStreamingState._valueForKey(key, VideoStreamingState._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VideoStreamingState._keyForValue(value, VideoStreamingState._MAP);\n    }\n}\n\nVideoStreamingState._MAP = Object.freeze({\n    'STREAMABLE': 'STREAMABLE',\n    'NOT_STREAMABLE': 'NOT_STREAMABLE',\n});\n\nexport { VideoStreamingState };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SystemContext } from '../enums/SystemContext.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcNotification } from '../RpcNotification.js';\nimport { AudioStreamingState } from '../enums/AudioStreamingState.js';\nimport { HMILevel } from '../enums/HMILevel.js';\nimport { VideoStreamingState } from '../enums/VideoStreamingState.js';\n\nclass OnHMIStatus extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnHMIStatus);\n    }\n\n    /**\n     * @param {HMILevel} level - See HMILevel\n     * @return {OnHMIStatus}\n     */\n    setHmiLevel (level) {\n        this.validateType(HMILevel, level);\n        this.setParameter(OnHMIStatus.KEY_HMI_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {HMILevel}\n     */\n    getHmiLevel () {\n        return this.getObject(HMILevel, OnHMIStatus.KEY_HMI_LEVEL);\n    }\n\n    /**\n     * @param {AudioStreamingState} state - See AudioStreamingState\n     * @return {OnHMIStatus}\n     */\n    setAudioStreamingState (state) {\n        this.validateType(AudioStreamingState, state);\n        this.setParameter(OnHMIStatus.KEY_AUDIO_STREAMING_STATE, state);\n        return this;\n    }\n\n    /**\n     * @return {AudioStreamingState}\n     */\n    getAudioStreamingState () {\n        return this.getObject(AudioStreamingState, OnHMIStatus.KEY_AUDIO_STREAMING_STATE);\n    }\n\n    /**\n     * @param {SystemContext} context - See SystemContext\n     * @return {OnHMIStatus}\n     */\n    setSystemContext (context) {\n        this.validateType(SystemContext, context);\n        this.setParameter(OnHMIStatus.KEY_SYSTEM_CONTEXT, context);\n        return this;\n    }\n\n    /**\n     * @return {SystemContext}\n     */\n    getSystemContext () {\n        return this.getObject(SystemContext, OnHMIStatus.KEY_SYSTEM_CONTEXT);\n    }\n\n    /**\n     * @param {VideoStreamingState} state - See VideoStreamingState. If it is NOT_STREAMABLE, the app must stop\n     *                                      streaming video to SDL Core(stop service).\n     * @return {OnHMIStatus}\n     */\n    setVideoStreamingState (state) {\n        this.validateType(VideoStreamingState, state);\n        this.setParameter(OnHMIStatus.KEY_VIDEO_STREAMING_STATE, state);\n        return this;\n    }\n\n    /**\n     * @return {VideoStreamingState}\n     */\n    getVideoStreamingState () {\n        return this.getObject(VideoStreamingState, OnHMIStatus.KEY_VIDEO_STREAMING_STATE);\n    }\n\n    /**\n     * @param {Number} id - This is the unique ID assigned to the window that this RPC is intended. If this param is not\n     *                      included, it will be assumed that this request is specifically for the main window on the\n     *                      main display. See PredefinedWindows enum.\n     * @return {OnHMIStatus}\n     */\n    setWindowID (id) {\n        this.setParameter(OnHMIStatus.KEY_WINDOW_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getWindowID () {\n        return this.getParameter(OnHMIStatus.KEY_WINDOW_ID);\n    }\n}\n\nOnHMIStatus.KEY_HMI_LEVEL = 'hmiLevel';\nOnHMIStatus.KEY_AUDIO_STREAMING_STATE = 'audioStreamingState';\nOnHMIStatus.KEY_SYSTEM_CONTEXT = 'systemContext';\nOnHMIStatus.KEY_VIDEO_STREAMING_STATE = 'videoStreamingState';\nOnHMIStatus.KEY_WINDOW_ID = 'windowID';\n\nexport { OnHMIStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Error code, which comes from the module side.\n * @typedef {Enum} AppInterfaceUnregisteredReason\n * @property {Object} _MAP\n */\nclass AppInterfaceUnregisteredReason extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get IGNITION_OFF () {\n        return AppInterfaceUnregisteredReason._MAP.IGNITION_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BLUETOOTH_OFF () {\n        return AppInterfaceUnregisteredReason._MAP.BLUETOOTH_OFF;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get USB_DISCONNECTED () {\n        return AppInterfaceUnregisteredReason._MAP.USB_DISCONNECTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get REQUEST_WHILE_IN_NONE_HMI_LEVEL () {\n        return AppInterfaceUnregisteredReason._MAP.REQUEST_WHILE_IN_NONE_HMI_LEVEL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TOO_MANY_REQUESTS () {\n        return AppInterfaceUnregisteredReason._MAP.TOO_MANY_REQUESTS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DRIVER_DISTRACTION_VIOLATION () {\n        return AppInterfaceUnregisteredReason._MAP.DRIVER_DISTRACTION_VIOLATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get LANGUAGE_CHANGE () {\n        return AppInterfaceUnregisteredReason._MAP.LANGUAGE_CHANGE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MASTER_RESET () {\n        return AppInterfaceUnregisteredReason._MAP.MASTER_RESET;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get FACTORY_DEFAULTS () {\n        return AppInterfaceUnregisteredReason._MAP.FACTORY_DEFAULTS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get APP_UNAUTHORIZED () {\n        return AppInterfaceUnregisteredReason._MAP.APP_UNAUTHORIZED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PROTOCOL_VIOLATION () {\n        return AppInterfaceUnregisteredReason._MAP.PROTOCOL_VIOLATION;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get UNSUPPORTED_HMI_RESOURCE () {\n        return AppInterfaceUnregisteredReason._MAP.UNSUPPORTED_HMI_RESOURCE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return AppInterfaceUnregisteredReason._valueForKey(key, AppInterfaceUnregisteredReason._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return AppInterfaceUnregisteredReason._keyForValue(value, AppInterfaceUnregisteredReason._MAP);\n    }\n}\n\nAppInterfaceUnregisteredReason._MAP = Object.freeze({\n    'IGNITION_OFF': 'IGNITION_OFF',\n    'BLUETOOTH_OFF': 'BLUETOOTH_OFF',\n    'USB_DISCONNECTED': 'USB_DISCONNECTED',\n    'REQUEST_WHILE_IN_NONE_HMI_LEVEL': 'REQUEST_WHILE_IN_NONE_HMI_LEVEL',\n    'TOO_MANY_REQUESTS': 'TOO_MANY_REQUESTS',\n    'DRIVER_DISTRACTION_VIOLATION': 'DRIVER_DISTRACTION_VIOLATION',\n    'LANGUAGE_CHANGE': 'LANGUAGE_CHANGE',\n    'MASTER_RESET': 'MASTER_RESET',\n    'FACTORY_DEFAULTS': 'FACTORY_DEFAULTS',\n    'APP_UNAUTHORIZED': 'APP_UNAUTHORIZED',\n    'PROTOCOL_VIOLATION': 'PROTOCOL_VIOLATION',\n    'UNSUPPORTED_HMI_RESOURCE': 'UNSUPPORTED_HMI_RESOURCE',\n});\n\nexport { AppInterfaceUnregisteredReason };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { AppInterfaceUnregisteredReason } from '../enums/AppInterfaceUnregisteredReason.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\nclass OnAppInterfaceUnregistered extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnAppInterfaceUnregistered);\n    }\n\n    /**\n     * @param {AppInterfaceUnregisteredReason} reason - See AppInterfaceUnregisteredReason\n     * @return {OnAppInterfaceUnregistered}\n     */\n    setReason (reason) {\n        this.validateType(AppInterfaceUnregisteredReason, reason);\n        this.setParameter(OnAppInterfaceUnregistered.KEY_REASON, reason);\n        return this;\n    }\n\n    /**\n     * @return {AppInterfaceUnregisteredReason}\n     */\n    getReason () {\n        return this.getObject(AppInterfaceUnregisteredReason, OnAppInterfaceUnregistered.KEY_REASON);\n    }\n}\n\nOnAppInterfaceUnregistered.KEY_REASON = 'reason';\n\nexport { OnAppInterfaceUnregistered };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} ButtonEventMode\n * @property {Object} _MAP\n */\nclass ButtonEventMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * A button has been released up\n     * @return {String}\n     */\n    static get BUTTONUP () {\n        return ButtonEventMode._MAP.BUTTONUP;\n    }\n\n    /**\n     * A button has been pressed down\n     * @return {String}\n     */\n    static get BUTTONDOWN () {\n        return ButtonEventMode._MAP.BUTTONDOWN;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return ButtonEventMode._valueForKey(key, ButtonEventMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return ButtonEventMode._keyForValue(value, ButtonEventMode._MAP);\n    }\n}\n\nButtonEventMode._MAP = Object.freeze({\n    'BUTTONUP': 'BUTTONUP',\n    'BUTTONDOWN': 'BUTTONDOWN',\n});\n\nexport { ButtonEventMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ButtonName } from '../enums/ButtonName.js';\nimport { ButtonEventMode } from '../enums/ButtonEventMode.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Notifies application of UP/DOWN events for buttons to which the application is subscribed.\n */\nclass OnButtonEvent extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnButtonEvent);\n    }\n\n    /**\n     * @param {ButtonName} name - Defines the hard (physical) and soft (touchscreen) buttons available from the module\n     * @return {OnButtonEvent}\n     */\n    setButtonName (name) {\n        this.validateType(ButtonName, name);\n        this.setParameter(OnButtonEvent.KEY_BUTTON_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {ButtonName}\n     */\n    getButtonName () {\n        return this.getObject(ButtonName, OnButtonEvent.KEY_BUTTON_NAME);\n    }\n\n    /**\n     * @param {ButtonEventMode} mode - Indicates whether this is an UP or DOWN event.\n     * @return {OnButtonEvent}\n     */\n    setButtonEventMode (mode) {\n        this.validateType(ButtonEventMode, mode);\n        this.setParameter(OnButtonEvent.KEY_BUTTON_EVENT_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {ButtonEventMode}\n     */\n    getButtonEventMode () {\n        return this.getObject(ButtonEventMode, OnButtonEvent.KEY_BUTTON_EVENT_MODE);\n    }\n\n    /**\n     * @param {Number} id - If ButtonName is \"CUSTOM_BUTTON\", this references the integer ID passed by a custom button.\n     *                      (e.g. softButton ID)\n     * @return {OnButtonEvent}\n     */\n    setCustomButtonID (id) {\n        this.setParameter(OnButtonEvent.KEY_CUSTOM_BUTTON_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCustomButtonID () {\n        return this.getParameter(OnButtonEvent.KEY_CUSTOM_BUTTON_ID);\n    }\n}\n\nOnButtonEvent.KEY_BUTTON_NAME = 'buttonName';\nOnButtonEvent.KEY_BUTTON_EVENT_MODE = 'buttonEventMode';\nOnButtonEvent.KEY_CUSTOM_BUTTON_ID = 'customButtonID';\n\nexport { OnButtonEvent };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ButtonPressMode } from '../enums/ButtonPressMode.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ButtonName } from '../enums/ButtonName.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Notifies application of LONG/SHORT press events for buttons to which the application is subscribed.\n */\nclass OnButtonPress extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnButtonPress);\n    }\n\n    /**\n     * @param {ButtonName} name - Defines the hard (physical) and soft (touchscreen) buttons available from the module\n     * @return {OnButtonPress}\n     */\n    setButtonName (name) {\n        this.validateType(ButtonName, name);\n        this.setParameter(OnButtonPress.KEY_BUTTON_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {ButtonName}\n     */\n    getButtonName () {\n        return this.getObject(ButtonName, OnButtonPress.KEY_BUTTON_NAME);\n    }\n\n    /**\n     * @param {ButtonPressMode} mode - Indicates whether this is a LONG or SHORT button press event.\n     * @return {OnButtonPress}\n     */\n    setButtonPressMode (mode) {\n        this.validateType(ButtonPressMode, mode);\n        this.setParameter(OnButtonPress.KEY_BUTTON_PRESS_MODE, mode);\n        return this;\n    }\n\n    /**\n     * @return {ButtonPressMode}\n     */\n    getButtonPressMode () {\n        return this.getObject(ButtonPressMode, OnButtonPress.KEY_BUTTON_PRESS_MODE);\n    }\n\n    /**\n     * @param {Number} id - If ButtonName is \"CUSTOM_BUTTON\", this references the integer ID passed by a custom button.\n     *                      (e.g. softButton ID)\n     * @return {OnButtonPress}\n     */\n    setCustomButtonID (id) {\n        this.setParameter(OnButtonPress.KEY_CUSTOM_BUTTON_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCustomButtonID () {\n        return this.getParameter(OnButtonPress.KEY_CUSTOM_BUTTON_ID);\n    }\n}\n\nOnButtonPress.KEY_BUTTON_NAME = 'buttonName';\nOnButtonPress.KEY_BUTTON_PRESS_MODE = 'buttonPressMode';\nOnButtonPress.KEY_CUSTOM_BUTTON_ID = 'customButtonID';\n\nexport { OnButtonPress };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { AirbagStatus } from '../structs/AirbagStatus.js';\nimport { ClusterModeStatus } from '../structs/ClusterModeStatus.js';\nimport { VehicleDataEventStatus } from '../enums/VehicleDataEventStatus.js';\nimport { EmergencyEvent } from '../structs/EmergencyEvent.js';\nimport { TurnSignal } from '../enums/TurnSignal.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { HeadLampStatus } from '../structs/HeadLampStatus.js';\nimport { DeviceStatus } from '../structs/DeviceStatus.js';\nimport { WiperStatus } from '../enums/WiperStatus.js';\nimport { RpcNotification } from '../RpcNotification.js';\nimport { ElectronicParkBrakeStatus } from '../enums/ElectronicParkBrakeStatus.js';\nimport { MyKey } from '../structs/MyKey.js';\nimport { GPSData } from '../structs/GPSData.js';\nimport { PRNDL } from '../enums/PRNDL.js';\nimport { FuelRange } from '../structs/FuelRange.js';\nimport { ECallInfo } from '../structs/ECallInfo.js';\nimport { BeltStatus } from '../structs/BeltStatus.js';\nimport { ComponentVolumeStatus } from '../enums/ComponentVolumeStatus.js';\nimport { BodyInformation } from '../structs/BodyInformation.js';\nimport { TireStatus } from '../structs/TireStatus.js';\n\n/**\n * Callback for the periodic and non periodic vehicle data read function.\n */\nclass OnVehicleData extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnVehicleData);\n    }\n\n    /**\n     * @param {GPSData} gps - See GPSData\n     * @return {OnVehicleData}\n     */\n    setGps (gps) {\n        this.validateType(GPSData, gps);\n        this.setParameter(OnVehicleData.KEY_GPS, gps);\n        return this;\n    }\n\n    /**\n     * @return {GPSData}\n     */\n    getGps () {\n        return this.getObject(GPSData, OnVehicleData.KEY_GPS);\n    }\n\n    /**\n     * @param {Number} speed - The vehicle speed in kilometers per hour\n     * @return {OnVehicleData}\n     */\n    setSpeed (speed) {\n        this.setParameter(OnVehicleData.KEY_SPEED, speed);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSpeed () {\n        return this.getParameter(OnVehicleData.KEY_SPEED);\n    }\n\n    /**\n     * @param {Number} rpm - The number of revolutions per minute of the engine\n     * @return {OnVehicleData}\n     */\n    setRpm (rpm) {\n        this.setParameter(OnVehicleData.KEY_RPM, rpm);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getRpm () {\n        return this.getParameter(OnVehicleData.KEY_RPM);\n    }\n\n    /**\n     * @param {Number} level - The fuel level in the tank (percentage)\n     * @return {OnVehicleData}\n     */\n    setFuelLevel (level) {\n        this.setParameter(OnVehicleData.KEY_FUEL_LEVEL, level);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getFuelLevel () {\n        return this.getParameter(OnVehicleData.KEY_FUEL_LEVEL);\n    }\n\n    /**\n     * @param {ComponentVolumeStatus} level_state - The fuel level state\n     * @return {OnVehicleData}\n     */\n    setFuelLevel_State (level_state) {\n        this.validateType(ComponentVolumeStatus, level_state);\n        this.setParameter(OnVehicleData.KEY_FUEL_LEVEL_STATE, level_state);\n        return this;\n    }\n\n    /**\n     * @return {ComponentVolumeStatus}\n     */\n    getFuelLevel_State () {\n        return this.getObject(ComponentVolumeStatus, OnVehicleData.KEY_FUEL_LEVEL_STATE);\n    }\n\n    /**\n     * @param {Number} consumption - The instantaneous fuel consumption in microlitres\n     * @return {OnVehicleData}\n     */\n    setInstantFuelConsumption (consumption) {\n        this.setParameter(OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION, consumption);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getInstantFuelConsumption () {\n        return this.getParameter(OnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION);\n    }\n\n    /**\n     * @param {FuelRange[]} range - The estimate range in KM the vehicle can travel based on fuel level and consumption\n     * @return {OnVehicleData}\n     */\n    setFuelRange (range) {\n        this.validateType(FuelRange, range, true);\n        this.setParameter(OnVehicleData.KEY_FUEL_RANGE, range);\n        return this;\n    }\n\n    /**\n     * @return {FuelRange[]}\n     */\n    getFuelRange () {\n        return this.getObject(FuelRange, OnVehicleData.KEY_FUEL_RANGE);\n    }\n\n    /**\n     * @param {Number} temperature - The external temperature in degrees celsius\n     * @return {OnVehicleData}\n     */\n    setExternalTemperature (temperature) {\n        this.setParameter(OnVehicleData.KEY_EXTERNAL_TEMPERATURE, temperature);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getExternalTemperature () {\n        return this.getParameter(OnVehicleData.KEY_EXTERNAL_TEMPERATURE);\n    }\n\n    /**\n     * @param {TurnSignal} signal - See TurnSignal\n     * @return {OnVehicleData}\n     */\n    setTurnSignal (signal) {\n        this.validateType(TurnSignal, signal);\n        this.setParameter(OnVehicleData.KEY_TURN_SIGNAL, signal);\n        return this;\n    }\n\n    /**\n     * @return {TurnSignal}\n     */\n    getTurnSignal () {\n        return this.getObject(TurnSignal, OnVehicleData.KEY_TURN_SIGNAL);\n    }\n\n    /**\n     * @param {String} vin - Vehicle identification number.\n     * @return {OnVehicleData}\n     */\n    setVin (vin) {\n        this.setParameter(OnVehicleData.KEY_VIN, vin);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getVin () {\n        return this.getParameter(OnVehicleData.KEY_VIN);\n    }\n\n    /**\n     * @param {PRNDL} prndl - See PRNDL\n     * @return {OnVehicleData}\n     */\n    setPrndl (prndl) {\n        this.validateType(PRNDL, prndl);\n        this.setParameter(OnVehicleData.KEY_PRNDL, prndl);\n        return this;\n    }\n\n    /**\n     * @return {PRNDL}\n     */\n    getPrndl () {\n        return this.getObject(PRNDL, OnVehicleData.KEY_PRNDL);\n    }\n\n    /**\n     * @param {TireStatus} pressure - See TireStatus\n     * @return {OnVehicleData}\n     */\n    setTirePressure (pressure) {\n        this.validateType(TireStatus, pressure);\n        this.setParameter(OnVehicleData.KEY_TIRE_PRESSURE, pressure);\n        return this;\n    }\n\n    /**\n     * @return {TireStatus}\n     */\n    getTirePressure () {\n        return this.getObject(TireStatus, OnVehicleData.KEY_TIRE_PRESSURE);\n    }\n\n    /**\n     * @param {Number} odometer - Odometer in km\n     * @return {OnVehicleData}\n     */\n    setOdometer (odometer) {\n        this.setParameter(OnVehicleData.KEY_ODOMETER, odometer);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getOdometer () {\n        return this.getParameter(OnVehicleData.KEY_ODOMETER);\n    }\n\n    /**\n     * @param {BeltStatus} status - The status of the seat belts\n     * @return {OnVehicleData}\n     */\n    setBeltStatus (status) {\n        this.validateType(BeltStatus, status);\n        this.setParameter(OnVehicleData.KEY_BELT_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {BeltStatus}\n     */\n    getBeltStatus () {\n        return this.getObject(BeltStatus, OnVehicleData.KEY_BELT_STATUS);\n    }\n\n    /**\n     * @param {BodyInformation} information - The body information including power modes\n     * @return {OnVehicleData}\n     */\n    setBodyInformation (information) {\n        this.validateType(BodyInformation, information);\n        this.setParameter(OnVehicleData.KEY_BODY_INFORMATION, information);\n        return this;\n    }\n\n    /**\n     * @return {BodyInformation}\n     */\n    getBodyInformation () {\n        return this.getObject(BodyInformation, OnVehicleData.KEY_BODY_INFORMATION);\n    }\n\n    /**\n     * @param {DeviceStatus} status - The device status including signal and battery strength\n     * @return {OnVehicleData}\n     */\n    setDeviceStatus (status) {\n        this.validateType(DeviceStatus, status);\n        this.setParameter(OnVehicleData.KEY_DEVICE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {DeviceStatus}\n     */\n    getDeviceStatus () {\n        return this.getObject(DeviceStatus, OnVehicleData.KEY_DEVICE_STATUS);\n    }\n\n    /**\n     * @param {VehicleDataEventStatus} braking - The status of the brake pedal\n     * @return {OnVehicleData}\n     */\n    setDriverBraking (braking) {\n        this.validateType(VehicleDataEventStatus, braking);\n        this.setParameter(OnVehicleData.KEY_DRIVER_BRAKING, braking);\n        return this;\n    }\n\n    /**\n     * @return {VehicleDataEventStatus}\n     */\n    getDriverBraking () {\n        return this.getObject(VehicleDataEventStatus, OnVehicleData.KEY_DRIVER_BRAKING);\n    }\n\n    /**\n     * @param {WiperStatus} status - The status of the wipers\n     * @return {OnVehicleData}\n     */\n    setWiperStatus (status) {\n        this.validateType(WiperStatus, status);\n        this.setParameter(OnVehicleData.KEY_WIPER_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {WiperStatus}\n     */\n    getWiperStatus () {\n        return this.getObject(WiperStatus, OnVehicleData.KEY_WIPER_STATUS);\n    }\n\n    /**\n     * @param {HeadLampStatus} status - Status of the head lamps\n     * @return {OnVehicleData}\n     */\n    setHeadLampStatus (status) {\n        this.validateType(HeadLampStatus, status);\n        this.setParameter(OnVehicleData.KEY_HEAD_LAMP_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {HeadLampStatus}\n     */\n    getHeadLampStatus () {\n        return this.getObject(HeadLampStatus, OnVehicleData.KEY_HEAD_LAMP_STATUS);\n    }\n\n    /**\n     * @param {Number} torque - Torque value for engine (in Nm) on non-diesel variants\n     * @return {OnVehicleData}\n     */\n    setEngineTorque (torque) {\n        this.setParameter(OnVehicleData.KEY_ENGINE_TORQUE, torque);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEngineTorque () {\n        return this.getParameter(OnVehicleData.KEY_ENGINE_TORQUE);\n    }\n\n    /**\n     * @param {Number} position - Accelerator pedal position (percentage depressed)\n     * @return {OnVehicleData}\n     */\n    setAccPedalPosition (position) {\n        this.setParameter(OnVehicleData.KEY_ACC_PEDAL_POSITION, position);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getAccPedalPosition () {\n        return this.getParameter(OnVehicleData.KEY_ACC_PEDAL_POSITION);\n    }\n\n    /**\n     * @param {Number} angle - Current angle of the steering wheel (in deg)\n     * @return {OnVehicleData}\n     */\n    setSteeringWheelAngle (angle) {\n        this.setParameter(OnVehicleData.KEY_STEERING_WHEEL_ANGLE, angle);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSteeringWheelAngle () {\n        return this.getParameter(OnVehicleData.KEY_STEERING_WHEEL_ANGLE);\n    }\n\n    /**\n     * @param {Number} life - The estimated percentage of remaining oil life of the engine.\n     * @return {OnVehicleData}\n     */\n    setEngineOilLife (life) {\n        this.setParameter(OnVehicleData.KEY_ENGINE_OIL_LIFE, life);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getEngineOilLife () {\n        return this.getParameter(OnVehicleData.KEY_ENGINE_OIL_LIFE);\n    }\n\n    /**\n     * @param {ElectronicParkBrakeStatus} status - The status of the park brake as provided by Electric Park Brake (EPB)\n     *                                             system.\n     * @return {OnVehicleData}\n     */\n    setElectronicParkBrakeStatus (status) {\n        this.validateType(ElectronicParkBrakeStatus, status);\n        this.setParameter(OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {ElectronicParkBrakeStatus}\n     */\n    getElectronicParkBrakeStatus () {\n        return this.getObject(ElectronicParkBrakeStatus, OnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS);\n    }\n\n    /**\n     * @param {String} id - Parameter used by cloud apps to identify a head unit\n     * @return {OnVehicleData}\n     */\n    setCloudAppVehicleID (id) {\n        this.setParameter(OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getCloudAppVehicleID () {\n        return this.getParameter(OnVehicleData.KEY_CLOUD_APP_VEHICLE_ID);\n    }\n\n    /**\n     * @param {ECallInfo} info - Emergency Call notification and confirmation data\n     * @return {OnVehicleData}\n     */\n    setECallInfo (info) {\n        this.validateType(ECallInfo, info);\n        this.setParameter(OnVehicleData.KEY_E_CALL_INFO, info);\n        return this;\n    }\n\n    /**\n     * @return {ECallInfo}\n     */\n    getECallInfo () {\n        return this.getObject(ECallInfo, OnVehicleData.KEY_E_CALL_INFO);\n    }\n\n    /**\n     * @param {AirbagStatus} status - The status of the air bags\n     * @return {OnVehicleData}\n     */\n    setAirbagStatus (status) {\n        this.validateType(AirbagStatus, status);\n        this.setParameter(OnVehicleData.KEY_AIRBAG_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {AirbagStatus}\n     */\n    getAirbagStatus () {\n        return this.getObject(AirbagStatus, OnVehicleData.KEY_AIRBAG_STATUS);\n    }\n\n    /**\n     * @param {EmergencyEvent} event - Information related to an emergency event (and if it occurred)\n     * @return {OnVehicleData}\n     */\n    setEmergencyEvent (event) {\n        this.validateType(EmergencyEvent, event);\n        this.setParameter(OnVehicleData.KEY_EMERGENCY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {EmergencyEvent}\n     */\n    getEmergencyEvent () {\n        return this.getObject(EmergencyEvent, OnVehicleData.KEY_EMERGENCY_EVENT);\n    }\n\n    /**\n     * @param {ClusterModeStatus} status - The status modes of the cluster\n     * @return {OnVehicleData}\n     */\n    setClusterModeStatus (status) {\n        this.validateType(ClusterModeStatus, status);\n        this.setParameter(OnVehicleData.KEY_CLUSTER_MODE_STATUS, status);\n        return this;\n    }\n\n    /**\n     * @return {ClusterModeStatus}\n     */\n    getClusterModeStatus () {\n        return this.getObject(ClusterModeStatus, OnVehicleData.KEY_CLUSTER_MODE_STATUS);\n    }\n\n    /**\n     * @param {MyKey} key - Information related to the MyKey feature\n     * @return {OnVehicleData}\n     */\n    setMyKey (key) {\n        this.validateType(MyKey, key);\n        this.setParameter(OnVehicleData.KEY_MY_KEY, key);\n        return this;\n    }\n\n    /**\n     * @return {MyKey}\n     */\n    getMyKey () {\n        return this.getObject(MyKey, OnVehicleData.KEY_MY_KEY);\n    }\n}\n\nOnVehicleData.KEY_GPS = 'gps';\nOnVehicleData.KEY_SPEED = 'speed';\nOnVehicleData.KEY_RPM = 'rpm';\nOnVehicleData.KEY_FUEL_LEVEL = 'fuelLevel';\nOnVehicleData.KEY_FUEL_LEVEL_STATE = 'fuelLevel_State';\nOnVehicleData.KEY_INSTANT_FUEL_CONSUMPTION = 'instantFuelConsumption';\nOnVehicleData.KEY_FUEL_RANGE = 'fuelRange';\nOnVehicleData.KEY_EXTERNAL_TEMPERATURE = 'externalTemperature';\nOnVehicleData.KEY_TURN_SIGNAL = 'turnSignal';\nOnVehicleData.KEY_VIN = 'vin';\nOnVehicleData.KEY_PRNDL = 'prndl';\nOnVehicleData.KEY_TIRE_PRESSURE = 'tirePressure';\nOnVehicleData.KEY_ODOMETER = 'odometer';\nOnVehicleData.KEY_BELT_STATUS = 'beltStatus';\nOnVehicleData.KEY_BODY_INFORMATION = 'bodyInformation';\nOnVehicleData.KEY_DEVICE_STATUS = 'deviceStatus';\nOnVehicleData.KEY_DRIVER_BRAKING = 'driverBraking';\nOnVehicleData.KEY_WIPER_STATUS = 'wiperStatus';\nOnVehicleData.KEY_HEAD_LAMP_STATUS = 'headLampStatus';\nOnVehicleData.KEY_ENGINE_TORQUE = 'engineTorque';\nOnVehicleData.KEY_ACC_PEDAL_POSITION = 'accPedalPosition';\nOnVehicleData.KEY_STEERING_WHEEL_ANGLE = 'steeringWheelAngle';\nOnVehicleData.KEY_ENGINE_OIL_LIFE = 'engineOilLife';\nOnVehicleData.KEY_ELECTRONIC_PARK_BRAKE_STATUS = 'electronicParkBrakeStatus';\nOnVehicleData.KEY_CLOUD_APP_VEHICLE_ID = 'cloudAppVehicleID';\nOnVehicleData.KEY_E_CALL_INFO = 'eCallInfo';\nOnVehicleData.KEY_AIRBAG_STATUS = 'airbagStatus';\nOnVehicleData.KEY_EMERGENCY_EVENT = 'emergencyEvent';\nOnVehicleData.KEY_CLUSTER_MODE_STATUS = 'clusterModeStatus';\nOnVehicleData.KEY_MY_KEY = 'myKey';\n\nexport { OnVehicleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TriggerSource } from '../enums/TriggerSource.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\nclass OnCommand extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnCommand);\n    }\n\n    /**\n     * @param {Number} id - Command ID, which is related to a specific menu entry\n     * @return {OnCommand}\n     */\n    setCmdID (id) {\n        this.setParameter(OnCommand.KEY_CMD_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getCmdID () {\n        return this.getParameter(OnCommand.KEY_CMD_ID);\n    }\n\n    /**\n     * @param {TriggerSource} source - See TriggerSource\n     * @return {OnCommand}\n     */\n    setTriggerSource (source) {\n        this.validateType(TriggerSource, source);\n        this.setParameter(OnCommand.KEY_TRIGGER_SOURCE, source);\n        return this;\n    }\n\n    /**\n     * @return {TriggerSource}\n     */\n    getTriggerSource () {\n        return this.getObject(TriggerSource, OnCommand.KEY_TRIGGER_SOURCE);\n    }\n}\n\nOnCommand.KEY_CMD_ID = 'cmdID';\nOnCommand.KEY_TRIGGER_SOURCE = 'triggerSource';\n\nexport { OnCommand };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes possible states of turn-by-turn client or SmartDeviceLink app.\n * @typedef {Enum} TBTState\n * @property {Object} _MAP\n */\nclass TBTState extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ROUTE_UPDATE_REQUEST () {\n        return TBTState._MAP.ROUTE_UPDATE_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ROUTE_ACCEPTED () {\n        return TBTState._MAP.ROUTE_ACCEPTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ROUTE_REFUSED () {\n        return TBTState._MAP.ROUTE_REFUSED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ROUTE_CANCELLED () {\n        return TBTState._MAP.ROUTE_CANCELLED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ETA_REQUEST () {\n        return TBTState._MAP.ETA_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NEXT_TURN_REQUEST () {\n        return TBTState._MAP.NEXT_TURN_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ROUTE_STATUS_REQUEST () {\n        return TBTState._MAP.ROUTE_STATUS_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ROUTE_SUMMARY_REQUEST () {\n        return TBTState._MAP.ROUTE_SUMMARY_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get TRIP_STATUS_REQUEST () {\n        return TBTState._MAP.TRIP_STATUS_REQUEST;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ROUTE_UPDATE_REQUEST_TIMEOUT () {\n        return TBTState._MAP.ROUTE_UPDATE_REQUEST_TIMEOUT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TBTState._valueForKey(key, TBTState._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TBTState._keyForValue(value, TBTState._MAP);\n    }\n}\n\nTBTState._MAP = Object.freeze({\n    'ROUTE_UPDATE_REQUEST': 'ROUTE_UPDATE_REQUEST',\n    'ROUTE_ACCEPTED': 'ROUTE_ACCEPTED',\n    'ROUTE_REFUSED': 'ROUTE_REFUSED',\n    'ROUTE_CANCELLED': 'ROUTE_CANCELLED',\n    'ETA_REQUEST': 'ETA_REQUEST',\n    'NEXT_TURN_REQUEST': 'NEXT_TURN_REQUEST',\n    'ROUTE_STATUS_REQUEST': 'ROUTE_STATUS_REQUEST',\n    'ROUTE_SUMMARY_REQUEST': 'ROUTE_SUMMARY_REQUEST',\n    'TRIP_STATUS_REQUEST': 'TRIP_STATUS_REQUEST',\n    'ROUTE_UPDATE_REQUEST_TIMEOUT': 'ROUTE_UPDATE_REQUEST_TIMEOUT',\n});\n\nexport { TBTState };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TBTState } from '../enums/TBTState.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Provides applications with notifications specific to the current TBT client status on the module\n */\nclass OnTBTClientState extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnTBTClientState);\n    }\n\n    /**\n     * @param {TBTState} state - Current State of TBT client\n     * @return {OnTBTClientState}\n     */\n    setState (state) {\n        this.validateType(TBTState, state);\n        this.setParameter(OnTBTClientState.KEY_STATE, state);\n        return this;\n    }\n\n    /**\n     * @return {TBTState}\n     */\n    getState () {\n        return this.getObject(TBTState, OnTBTClientState.KEY_STATE);\n    }\n}\n\nOnTBTClientState.KEY_STATE = 'state';\n\nexport { OnTBTClientState };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes possible states of driver distraction.\n * @typedef {Enum} DriverDistractionState\n * @property {Object} _MAP\n */\nclass DriverDistractionState extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DD_ON () {\n        return DriverDistractionState._MAP.DD_ON;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get DD_OFF () {\n        return DriverDistractionState._MAP.DD_OFF;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return DriverDistractionState._valueForKey(key, DriverDistractionState._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return DriverDistractionState._keyForValue(value, DriverDistractionState._MAP);\n    }\n}\n\nDriverDistractionState._MAP = Object.freeze({\n    'DD_ON': 'DD_ON',\n    'DD_OFF': 'DD_OFF',\n});\n\nexport { DriverDistractionState };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { DriverDistractionState } from '../enums/DriverDistractionState.js';\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Provides driver distraction state to mobile applications\n */\nclass OnDriverDistraction extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnDriverDistraction);\n    }\n\n    /**\n     * @param {DriverDistractionState} state - Current State of Driver Distraction\n     * @return {OnDriverDistraction}\n     */\n    setState (state) {\n        this.validateType(DriverDistractionState, state);\n        this.setParameter(OnDriverDistraction.KEY_STATE, state);\n        return this;\n    }\n\n    /**\n     * @return {DriverDistractionState}\n     */\n    getState () {\n        return this.getObject(DriverDistractionState, OnDriverDistraction.KEY_STATE);\n    }\n\n    /**\n     * @param {Boolean} enabled - If enabled, the lock screen will be able to be dismissed while connected to SDL,\n     *                            allowing users the ability to interact with the app. Dismissals should include a\n     *                            warning to the user and ensure that they are not the driver.\n     * @return {OnDriverDistraction}\n     */\n    setLockScreenDismissalEnabled (enabled) {\n        this.setParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED, enabled);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getLockScreenDismissalEnabled () {\n        return this.getParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED);\n    }\n\n    /**\n     * @param {String} warning - Warning message to be displayed on the lock screen when dismissal is enabled. This\n     *                           warning should be used to ensure that the user is not the driver of the vehicle, ex.\n     *                           `Swipe down to dismiss, acknowledging that you are not the driver.`. This parameter\n     *                           must be present if \"lockScreenDismissalEnabled\" is set to true.\n     * @return {OnDriverDistraction}\n     */\n    setLockScreenDismissalWarning (warning) {\n        this.setParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING, warning);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getLockScreenDismissalWarning () {\n        return this.getParameter(OnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING);\n    }\n}\n\nOnDriverDistraction.KEY_STATE = 'state';\nOnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_ENABLED = 'lockScreenDismissalEnabled';\nOnDriverDistraction.KEY_LOCK_SCREEN_DISMISSAL_WARNING = 'lockScreenDismissalWarning';\n\nexport { OnDriverDistraction };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { HMILevel } from '../enums/HMILevel.js';\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass HMIPermissions extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {HMILevel[]} allowed - A set of all HMI levels that are permitted for this given RPC.\n     * @return {HMIPermissions}\n     */\n    setAllowed (allowed) {\n        this.validateType(HMILevel, allowed, true);\n        this.setParameter(HMIPermissions.KEY_ALLOWED, allowed);\n        return this;\n    }\n\n    /**\n     * @return {HMILevel[]}\n     */\n    getAllowed () {\n        return this.getObject(HMILevel, HMIPermissions.KEY_ALLOWED);\n    }\n\n    /**\n     * @param {HMILevel[]} disallowed - A set of all HMI levels that are prohibited for this given RPC.\n     * @return {HMIPermissions}\n     */\n    setUserDisallowed (disallowed) {\n        this.validateType(HMILevel, disallowed, true);\n        this.setParameter(HMIPermissions.KEY_USER_DISALLOWED, disallowed);\n        return this;\n    }\n\n    /**\n     * @return {HMILevel[]}\n     */\n    getUserDisallowed () {\n        return this.getObject(HMILevel, HMIPermissions.KEY_USER_DISALLOWED);\n    }\n}\n\nHMIPermissions.KEY_ALLOWED = 'allowed';\nHMIPermissions.KEY_USER_DISALLOWED = 'userDisallowed';\n\nexport { HMIPermissions };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass ParameterPermissions extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String[]} allowed - A set of all parameters that are permitted for this given RPC.\n     * @return {ParameterPermissions}\n     */\n    setAllowed (allowed) {\n        this.setParameter(ParameterPermissions.KEY_ALLOWED, allowed);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getAllowed () {\n        return this.getParameter(ParameterPermissions.KEY_ALLOWED);\n    }\n\n    /**\n     * @param {String[]} disallowed - A set of all parameters that are prohibited for this given RPC.\n     * @return {ParameterPermissions}\n     */\n    setUserDisallowed (disallowed) {\n        this.setParameter(ParameterPermissions.KEY_USER_DISALLOWED, disallowed);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getUserDisallowed () {\n        return this.getParameter(ParameterPermissions.KEY_USER_DISALLOWED);\n    }\n}\n\nParameterPermissions.KEY_ALLOWED = 'allowed';\nParameterPermissions.KEY_USER_DISALLOWED = 'userDisallowed';\n\nexport { ParameterPermissions };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { HMIPermissions } from './HMIPermissions.js';\nimport { ParameterPermissions } from './ParameterPermissions.js';\n\nclass PermissionItem extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {String} name - Name of the individual RPC in the policy table.\n     * @return {PermissionItem}\n     */\n    setRpcName (name) {\n        this.setParameter(PermissionItem.KEY_RPC_NAME, name);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getRpcName () {\n        return this.getParameter(PermissionItem.KEY_RPC_NAME);\n    }\n\n    /**\n     * @param {HMIPermissions} permissions\n     * @return {PermissionItem}\n     */\n    setHmiPermissions (permissions) {\n        this.validateType(HMIPermissions, permissions);\n        this.setParameter(PermissionItem.KEY_HMI_PERMISSIONS, permissions);\n        return this;\n    }\n\n    /**\n     * @return {HMIPermissions}\n     */\n    getHmiPermissions () {\n        return this.getObject(HMIPermissions, PermissionItem.KEY_HMI_PERMISSIONS);\n    }\n\n    /**\n     * @param {ParameterPermissions} permissions\n     * @return {PermissionItem}\n     */\n    setParameterPermissions (permissions) {\n        this.validateType(ParameterPermissions, permissions);\n        this.setParameter(PermissionItem.KEY_PARAMETER_PERMISSIONS, permissions);\n        return this;\n    }\n\n    /**\n     * @return {ParameterPermissions}\n     */\n    getParameterPermissions () {\n        return this.getObject(ParameterPermissions, PermissionItem.KEY_PARAMETER_PERMISSIONS);\n    }\n\n    /**\n     * @param {Boolean} encryption\n     * @return {PermissionItem}\n     */\n    setRequireEncryption (encryption) {\n        this.setParameter(PermissionItem.KEY_REQUIRE_ENCRYPTION, encryption);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRequireEncryption () {\n        return this.getParameter(PermissionItem.KEY_REQUIRE_ENCRYPTION);\n    }\n}\n\nPermissionItem.KEY_RPC_NAME = 'rpcName';\nPermissionItem.KEY_HMI_PERMISSIONS = 'hmiPermissions';\nPermissionItem.KEY_PARAMETER_PERMISSIONS = 'parameterPermissions';\nPermissionItem.KEY_REQUIRE_ENCRYPTION = 'requireEncryption';\n\nexport { PermissionItem };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { PermissionItem } from '../structs/PermissionItem.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Provides update to app of which policy-table-enabled functions are available\n */\nclass OnPermissionsChange extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnPermissionsChange);\n    }\n\n    /**\n     * @param {PermissionItem[]} item - Change in permissions for a given set of RPCs\n     * @return {OnPermissionsChange}\n     */\n    setPermissionItem (item) {\n        this.validateType(PermissionItem, item, true);\n        this.setParameter(OnPermissionsChange.KEY_PERMISSION_ITEM, item);\n        return this;\n    }\n\n    /**\n     * @return {PermissionItem[]}\n     */\n    getPermissionItem () {\n        return this.getObject(PermissionItem, OnPermissionsChange.KEY_PERMISSION_ITEM);\n    }\n\n    /**\n     * @param {Boolean} encryption\n     * @return {OnPermissionsChange}\n     */\n    setRequireEncryption (encryption) {\n        this.setParameter(OnPermissionsChange.KEY_REQUIRE_ENCRYPTION, encryption);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getRequireEncryption () {\n        return this.getParameter(OnPermissionsChange.KEY_REQUIRE_ENCRYPTION);\n    }\n}\n\nOnPermissionsChange.KEY_PERMISSION_ITEM = 'permissionItem';\nOnPermissionsChange.KEY_REQUIRE_ENCRYPTION = 'requireEncryption';\n\nexport { OnPermissionsChange };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Binary data is in binary part of hybrid msg\n */\nclass OnAudioPassThru extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnAudioPassThru);\n    }\n}\n\n\nexport { OnAudioPassThru };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { Language } from '../enums/Language.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\nclass OnLanguageChange extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnLanguageChange);\n    }\n\n    /**\n     * @param {Language} language - Current SDL voice engine (VR+TTS) language\n     * @return {OnLanguageChange}\n     */\n    setLanguage (language) {\n        this.validateType(Language, language);\n        this.setParameter(OnLanguageChange.KEY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getLanguage () {\n        return this.getObject(Language, OnLanguageChange.KEY_LANGUAGE);\n    }\n\n    /**\n     * @param {Language} language - Current display language\n     * @return {OnLanguageChange}\n     */\n    setHmiDisplayLanguage (language) {\n        this.validateType(Language, language);\n        this.setParameter(OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE, language);\n        return this;\n    }\n\n    /**\n     * @return {Language}\n     */\n    getHmiDisplayLanguage () {\n        return this.getObject(Language, OnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE);\n    }\n}\n\nOnLanguageChange.KEY_LANGUAGE = 'language';\nOnLanguageChange.KEY_HMI_DISPLAY_LANGUAGE = 'hmiDisplayLanguage';\n\nexport { OnLanguageChange };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration listing possible keyboard events.\n * @typedef {Enum} KeyboardEvent\n * @property {Object} _MAP\n */\nclass KeyboardEvent extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get KEYPRESS () {\n        return KeyboardEvent._MAP.KEYPRESS;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ENTRY_SUBMITTED () {\n        return KeyboardEvent._MAP.ENTRY_SUBMITTED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ENTRY_VOICE () {\n        return KeyboardEvent._MAP.ENTRY_VOICE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ENTRY_CANCELLED () {\n        return KeyboardEvent._MAP.ENTRY_CANCELLED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get ENTRY_ABORTED () {\n        return KeyboardEvent._MAP.ENTRY_ABORTED;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return KeyboardEvent._valueForKey(key, KeyboardEvent._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return KeyboardEvent._keyForValue(value, KeyboardEvent._MAP);\n    }\n}\n\nKeyboardEvent._MAP = Object.freeze({\n    'KEYPRESS': 'KEYPRESS',\n    'ENTRY_SUBMITTED': 'ENTRY_SUBMITTED',\n    'ENTRY_VOICE': 'ENTRY_VOICE',\n    'ENTRY_CANCELLED': 'ENTRY_CANCELLED',\n    'ENTRY_ABORTED': 'ENTRY_ABORTED',\n});\n\nexport { KeyboardEvent };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { KeyboardEvent } from '../enums/KeyboardEvent.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * On-screen keyboard event. Can be full string or individual keypresses depending on keyboard mode.\n */\nclass OnKeyboardInput extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnKeyboardInput);\n    }\n\n    /**\n     * @param {KeyboardEvent} event - On-screen keyboard input data.\n     * @return {OnKeyboardInput}\n     */\n    setEvent (event) {\n        this.validateType(KeyboardEvent, event);\n        this.setParameter(OnKeyboardInput.KEY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {KeyboardEvent}\n     */\n    getEvent () {\n        return this.getObject(KeyboardEvent, OnKeyboardInput.KEY_EVENT);\n    }\n\n    /**\n     * @param {String} data - On-screen keyboard input data. For dynamic keypress events, this will be the current\n     *                        compounded string of entry text. For entry submission events, this will be the full text\n     *                        entry (this will always return regardless of the mode). For entry cancelled and entry\n     *                        aborted events, this data param will be omitted.\n     * @return {OnKeyboardInput}\n     */\n    setData (data) {\n        this.setParameter(OnKeyboardInput.KEY_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getData () {\n        return this.getParameter(OnKeyboardInput.KEY_DATA);\n    }\n}\n\nOnKeyboardInput.KEY_EVENT = 'event';\nOnKeyboardInput.KEY_DATA = 'data';\n\nexport { OnKeyboardInput };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\n\nclass TouchCoord extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} x - The x coordinate of the touch.\n     * @return {TouchCoord}\n     */\n    setX (x) {\n        this.setParameter(TouchCoord.KEY_X, x);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getX () {\n        return this.getParameter(TouchCoord.KEY_X);\n    }\n\n    /**\n     * @param {Number} y - The y coordinate of the touch.\n     * @return {TouchCoord}\n     */\n    setY (y) {\n        this.setParameter(TouchCoord.KEY_Y, y);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getY () {\n        return this.getParameter(TouchCoord.KEY_Y);\n    }\n}\n\nTouchCoord.KEY_X = 'x';\nTouchCoord.KEY_Y = 'y';\n\nexport { TouchCoord };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcStruct } from '../RpcStruct.js';\nimport { TouchCoord } from './TouchCoord.js';\n\nclass TouchEvent extends RpcStruct {\n    /**\n     * @constructor\n     */\n    constructor (parameters) {\n        super(parameters);\n    }\n\n    /**\n     * @param {Number} id - A touch's unique identifier. The application can track the current touch events by id. If a\n     *                      touch event has type begin, the id should be added to the set of touches. If a touch event\n     *                      has type end, the id should be removed from the set of touches.\n     * @return {TouchEvent}\n     */\n    setId (id) {\n        this.setParameter(TouchEvent.KEY_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getId () {\n        return this.getParameter(TouchEvent.KEY_ID);\n    }\n\n    /**\n     * @param {Number[]} ts - The time that the touch was recorded. This number can the time since the beginning of the\n     *                        session or something else as long as the units are in milliseconds. The timestamp is used\n     *                        to determined the rate of change of position of a touch. The application also uses the\n     *                        time to verify whether two touches, with different ids, are part of a single action by the\n     *                        user. If there is only a single timestamp in this array, it is the same for every\n     *                        coordinate in the coordinates array.\n     * @return {TouchEvent}\n     */\n    setTs (ts) {\n        this.setParameter(TouchEvent.KEY_TS, ts);\n        return this;\n    }\n\n    /**\n     * @return {Number[]}\n     */\n    getTs () {\n        return this.getParameter(TouchEvent.KEY_TS);\n    }\n\n    /**\n     * @param {TouchCoord[]} c\n     * @return {TouchEvent}\n     */\n    setC (c) {\n        this.validateType(TouchCoord, c, true);\n        this.setParameter(TouchEvent.KEY_C, c);\n        return this;\n    }\n\n    /**\n     * @return {TouchCoord[]}\n     */\n    getC () {\n        return this.getObject(TouchCoord, TouchEvent.KEY_C);\n    }\n}\n\nTouchEvent.KEY_ID = 'id';\nTouchEvent.KEY_TS = 'ts';\nTouchEvent.KEY_C = 'c';\n\nexport { TouchEvent };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TouchType\n * @property {Object} _MAP\n */\nclass TouchType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get BEGIN () {\n        return TouchType._MAP.BEGIN;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MOVE () {\n        return TouchType._MAP.MOVE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get END () {\n        return TouchType._MAP.END;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get CANCEL () {\n        return TouchType._MAP.CANCEL;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TouchType._valueForKey(key, TouchType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TouchType._keyForValue(value, TouchType._MAP);\n    }\n}\n\nTouchType._MAP = Object.freeze({\n    'BEGIN': 'BEGIN',\n    'MOVE': 'MOVE',\n    'END': 'END',\n    'CANCEL': 'CANCEL',\n});\n\nexport { TouchType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { TouchEvent } from '../structs/TouchEvent.js';\nimport { TouchType } from '../enums/TouchType.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Notifies about touch events on the screen's prescribed area\n */\nclass OnTouchEvent extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnTouchEvent);\n    }\n\n    /**\n     * @param {TouchType} type - The type of touch event.\n     * @return {OnTouchEvent}\n     */\n    setType (type) {\n        this.validateType(TouchType, type);\n        this.setParameter(OnTouchEvent.KEY_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {TouchType}\n     */\n    getType () {\n        return this.getObject(TouchType, OnTouchEvent.KEY_TYPE);\n    }\n\n    /**\n     * @param {TouchEvent[]} event - List of all individual touches involved in this event.\n     * @return {OnTouchEvent}\n     */\n    setEvent (event) {\n        this.validateType(TouchEvent, event, true);\n        this.setParameter(OnTouchEvent.KEY_EVENT, event);\n        return this;\n    }\n\n    /**\n     * @return {TouchEvent[]}\n     */\n    getEvent () {\n        return this.getObject(TouchEvent, OnTouchEvent.KEY_EVENT);\n    }\n}\n\nOnTouchEvent.KEY_TYPE = 'type';\nOnTouchEvent.KEY_EVENT = 'event';\n\nexport { OnTouchEvent };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RequestType } from '../enums/RequestType.js';\nimport { FileType } from '../enums/FileType.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * An asynchronous request from the system for specific data from the device or the cloud or response to a request from\n * the device or cloud Binary data can be included in hybrid part of message for some requests (such as Authentication\n * request responses)\n */\nclass OnSystemRequest extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnSystemRequest);\n    }\n\n    /**\n     * @param {RequestType} type - The type of system request.\n     * @return {OnSystemRequest}\n     */\n    setRequestType (type) {\n        this.validateType(RequestType, type);\n        this.setParameter(OnSystemRequest.KEY_REQUEST_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {RequestType}\n     */\n    getRequestType () {\n        return this.getObject(RequestType, OnSystemRequest.KEY_REQUEST_TYPE);\n    }\n\n    /**\n     * @param {String} type - This parameter is filled for supporting OEM proprietary data exchanges.\n     * @return {OnSystemRequest}\n     */\n    setRequestSubType (type) {\n        this.setParameter(OnSystemRequest.KEY_REQUEST_SUB_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getRequestSubType () {\n        return this.getParameter(OnSystemRequest.KEY_REQUEST_SUB_TYPE);\n    }\n\n    /**\n     * @param {String} url - Optional URL for HTTP requests. If blank, the binary data shall be forwarded to the app. If\n     *                       not blank, the binary data shall be forwarded to the url with a provided timeout in\n     *                       seconds.\n     * @return {OnSystemRequest}\n     */\n    setUrl (url) {\n        this.setParameter(OnSystemRequest.KEY_URL, url);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getUrl () {\n        return this.getParameter(OnSystemRequest.KEY_URL);\n    }\n\n    /**\n     * @param {Number} timeout - Optional timeout for HTTP requests Required if a URL is provided\n     * @return {OnSystemRequest}\n     */\n    setTimeout (timeout) {\n        this.setParameter(OnSystemRequest.KEY_TIMEOUT, timeout);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTimeout () {\n        return this.getParameter(OnSystemRequest.KEY_TIMEOUT);\n    }\n\n    /**\n     * @param {FileType} type - Optional file type (meant for HTTP file requests).\n     * @return {OnSystemRequest}\n     */\n    setFileType (type) {\n        this.validateType(FileType, type);\n        this.setParameter(OnSystemRequest.KEY_FILE_TYPE, type);\n        return this;\n    }\n\n    /**\n     * @return {FileType}\n     */\n    getFileType () {\n        return this.getObject(FileType, OnSystemRequest.KEY_FILE_TYPE);\n    }\n\n    /**\n     * @param {Number} offset - Optional offset in bytes for resuming partial data chunks\n     * @return {OnSystemRequest}\n     */\n    setOffset (offset) {\n        this.setParameter(OnSystemRequest.KEY_OFFSET, offset);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getOffset () {\n        return this.getParameter(OnSystemRequest.KEY_OFFSET);\n    }\n\n    /**\n     * @param {Number} length - Optional length in bytes for resuming partial data chunks\n     * @return {OnSystemRequest}\n     */\n    setLength (length) {\n        this.setParameter(OnSystemRequest.KEY_LENGTH, length);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getLength () {\n        return this.getParameter(OnSystemRequest.KEY_LENGTH);\n    }\n}\n\nOnSystemRequest.KEY_REQUEST_TYPE = 'requestType';\nOnSystemRequest.KEY_REQUEST_SUB_TYPE = 'requestSubType';\nOnSystemRequest.KEY_URL = 'url';\nOnSystemRequest.KEY_TIMEOUT = 'timeout';\nOnSystemRequest.KEY_FILE_TYPE = 'fileType';\nOnSystemRequest.KEY_OFFSET = 'offset';\nOnSystemRequest.KEY_LENGTH = 'length';\n\nexport { OnSystemRequest };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Notification containing an updated hashID which can be used over connection cycles (i.e. loss of connection,\n * ignition cycles, etc.). Sent after initial registration and subsequently after any change in the calculated hash of\n * all persisted app data.\n */\nclass OnHashChange extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnHashChange);\n    }\n\n    /**\n     * @param {String} id - Calculated hash ID to be referenced during RegisterAppInterface.\n     * @return {OnHashChange}\n     */\n    setHashID (id) {\n        this.setParameter(OnHashChange.KEY_HASH_ID, id);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getHashID () {\n        return this.getParameter(OnHashChange.KEY_HASH_ID);\n    }\n}\n\nOnHashChange.KEY_HASH_ID = 'hashID';\n\nexport { OnHashChange };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { LocationDetails } from '../structs/LocationDetails.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Notification which provides the entire LocationDetails when there is a change to any waypoints or destination.\n */\nclass OnWayPointChange extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnWayPointChange);\n    }\n\n    /**\n     * @param {LocationDetails[]} points - See LocationDetails\n     * @return {OnWayPointChange}\n     */\n    setWayPoints (points) {\n        this.validateType(LocationDetails, points, true);\n        this.setParameter(OnWayPointChange.KEY_WAY_POINTS, points);\n        return this;\n    }\n\n    /**\n     * @return {LocationDetails[]}\n     */\n    getWayPoints () {\n        return this.getObject(LocationDetails, OnWayPointChange.KEY_WAY_POINTS);\n    }\n}\n\nOnWayPointChange.KEY_WAY_POINTS = 'wayPoints';\n\nexport { OnWayPointChange };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ModuleData } from '../structs/ModuleData.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\nclass OnInteriorVehicleData extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnInteriorVehicleData);\n    }\n\n    /**\n     * @param {ModuleData} data - The moduleType indicates which type of data should be changed and identifies which\n     *                            data object exists in this struct. For example, if the moduleType is CLIMATE then a\n     *                            \"climateControlData\" should exist\n     * @return {OnInteriorVehicleData}\n     */\n    setModuleData (data) {\n        this.validateType(ModuleData, data);\n        this.setParameter(OnInteriorVehicleData.KEY_MODULE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {ModuleData}\n     */\n    getModuleData () {\n        return this.getObject(ModuleData, OnInteriorVehicleData.KEY_MODULE_DATA);\n    }\n}\n\nOnInteriorVehicleData.KEY_MODULE_DATA = 'moduleData';\n\nexport { OnInteriorVehicleData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { ModuleData } from '../structs/ModuleData.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Issued by SDL to notify the application about remote control status change on SDL\n */\nclass OnRCStatus extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnRCStatus);\n    }\n\n    /**\n     * @param {Boolean} allowed - If \"true\" - RC is allowed; if \"false\" - RC is disallowed.\n     * @return {OnRCStatus}\n     */\n    setAllowed (allowed) {\n        this.setParameter(OnRCStatus.KEY_ALLOWED, allowed);\n        return this;\n    }\n\n    /**\n     * @return {Boolean}\n     */\n    getAllowed () {\n        return this.getParameter(OnRCStatus.KEY_ALLOWED);\n    }\n\n    /**\n     * @param {ModuleData[]} modules - Contains a list (zero or more) of module types that are allocated to the\n     *                                 application.\n     * @return {OnRCStatus}\n     */\n    setAllocatedModules (modules) {\n        this.validateType(ModuleData, modules, true);\n        this.setParameter(OnRCStatus.KEY_ALLOCATED_MODULES, modules);\n        return this;\n    }\n\n    /**\n     * @return {ModuleData[]}\n     */\n    getAllocatedModules () {\n        return this.getObject(ModuleData, OnRCStatus.KEY_ALLOCATED_MODULES);\n    }\n\n    /**\n     * @param {ModuleData[]} modules - Contains a list (zero or more) of module types that are free to access for the\n     *                                 application.\n     * @return {OnRCStatus}\n     */\n    setFreeModules (modules) {\n        this.validateType(ModuleData, modules, true);\n        this.setParameter(OnRCStatus.KEY_FREE_MODULES, modules);\n        return this;\n    }\n\n    /**\n     * @return {ModuleData[]}\n     */\n    getFreeModules () {\n        return this.getObject(ModuleData, OnRCStatus.KEY_FREE_MODULES);\n    }\n}\n\nOnRCStatus.KEY_ALLOWED = 'allowed';\nOnRCStatus.KEY_ALLOCATED_MODULES = 'allocatedModules';\nOnRCStatus.KEY_FREE_MODULES = 'freeModules';\n\nexport { OnRCStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { AppServiceData } from '../structs/AppServiceData.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * This notification includes the data that is updated from the specific service\n */\nclass OnAppServiceData extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnAppServiceData);\n    }\n\n    /**\n     * @param {AppServiceData} data - Contains all the current data of the app service. The serviceType will link to\n     *                                which of the service data objects are included in this object (e.g. if the service\n     *                                type is MEDIA, the mediaServiceData param should be included).\n     * @return {OnAppServiceData}\n     */\n    setServiceData (data) {\n        this.validateType(AppServiceData, data);\n        this.setParameter(OnAppServiceData.KEY_SERVICE_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {AppServiceData}\n     */\n    getServiceData () {\n        return this.getObject(AppServiceData, OnAppServiceData.KEY_SERVICE_DATA);\n    }\n}\n\nOnAppServiceData.KEY_SERVICE_DATA = 'serviceData';\n\nexport { OnAppServiceData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { SystemCapability } from '../structs/SystemCapability.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * A notification to inform the connected device that a specific system capability has changed.\n */\nclass OnSystemCapabilityUpdated extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnSystemCapabilityUpdated);\n    }\n\n    /**\n     * @param {SystemCapability} capability - The system capability that has been updated\n     * @return {OnSystemCapabilityUpdated}\n     */\n    setSystemCapability (capability) {\n        this.validateType(SystemCapability, capability);\n        this.setParameter(OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY, capability);\n        return this;\n    }\n\n    /**\n     * @return {SystemCapability}\n     */\n    getSystemCapability () {\n        return this.getObject(SystemCapability, OnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY);\n    }\n}\n\nOnSystemCapabilityUpdated.KEY_SYSTEM_CAPABILITY = 'systemCapability';\n\nexport { OnSystemCapabilityUpdated };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RpcRequest } from '../RpcRequest.js';\nimport { FunctionID } from '../enums/FunctionID.js';\n\n/**\n * Allows encoded data in the form of SyncP packets to be sent to the SYNC module. Legacy / v1 Protocol implementation;\n * use SyncPData instead. *** DEPRECATED ***\n */\nclass EncodedSyncPData extends RpcRequest {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.EncodedSyncPData);\n    }\n\n    /**\n     * @param {String[]} data - Contains base64 encoded string of SyncP packets.\n     * @return {EncodedSyncPData}\n     */\n    setData (data) {\n        this.setParameter(EncodedSyncPData.KEY_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getData () {\n        return this.getParameter(EncodedSyncPData.KEY_DATA);\n    }\n}\n\nEncodedSyncPData.KEY_DATA = 'data';\n\nexport { EncodedSyncPData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcResponse } from '../RpcResponse.js';\n\nclass EncodedSyncPDataResponse extends RpcResponse {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.EncodedSyncPData);\n    }\n}\n\n\nexport { EncodedSyncPDataResponse };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { FunctionID } from '../enums/FunctionID.js';\nimport { RpcNotification } from '../RpcNotification.js';\n\n/**\n * Callback including encoded data of any SyncP packets that SYNC needs to send back to the mobile device. Legacy / v1\n * Protocol implementation; responds to EncodedSyncPData. *** DEPRECATED ***\n */\nclass OnEncodedSyncPData extends RpcNotification {\n    /**\n     * @constructor\n     */\n    constructor (store) {\n        super(store);\n        this.setFunctionName(FunctionID.OnEncodedSyncPData);\n    }\n\n    /**\n     * @param {String[]} data - Contains base64 encoded string of SyncP packets.\n     * @return {OnEncodedSyncPData}\n     */\n    setData (data) {\n        this.setParameter(OnEncodedSyncPData.KEY_DATA, data);\n        return this;\n    }\n\n    /**\n     * @return {String[]}\n     */\n    getData () {\n        return this.getParameter(OnEncodedSyncPData.KEY_DATA);\n    }\n\n    /**\n     * @param {String} url - If blank, the SyncP data shall be forwarded to the app. If not blank, the SyncP data shall\n     *                       be forwarded to the provided URL.\n     * @return {OnEncodedSyncPData}\n     */\n    setURL (url) {\n        this.setParameter(OnEncodedSyncPData.KEY_URL, url);\n        return this;\n    }\n\n    /**\n     * @return {String}\n     */\n    getURL () {\n        return this.getParameter(OnEncodedSyncPData.KEY_URL);\n    }\n\n    /**\n     * @param {Number} timeout - If blank, the SyncP data shall be forwarded to the app. If not blank, the SyncP data\n     *                           shall be forwarded with the provided timeout in seconds.\n     * @return {OnEncodedSyncPData}\n     */\n    setTimeout (timeout) {\n        this.setParameter(OnEncodedSyncPData.KEY_TIMEOUT, timeout);\n        return this;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getTimeout () {\n        return this.getParameter(OnEncodedSyncPData.KEY_TIMEOUT);\n    }\n}\n\nOnEncodedSyncPData.KEY_DATA = 'data';\nOnEncodedSyncPData.KEY_URL = 'URL';\nOnEncodedSyncPData.KEY_TIMEOUT = 'Timeout';\n\nexport { OnEncodedSyncPData };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n// messages\nimport { RegisterAppInterface } from './messages/RegisterAppInterface.js';\nimport { RegisterAppInterfaceResponse } from './messages/RegisterAppInterfaceResponse.js';\nimport { UnregisterAppInterface } from './messages/UnregisterAppInterface.js';\nimport { UnregisterAppInterfaceResponse } from './messages/UnregisterAppInterfaceResponse.js';\nimport { CreateWindow } from './messages/CreateWindow.js';\nimport { CreateWindowResponse } from './messages/CreateWindowResponse.js';\nimport { DeleteWindow } from './messages/DeleteWindow.js';\nimport { DeleteWindowResponse } from './messages/DeleteWindowResponse.js';\nimport { SetGlobalProperties } from './messages/SetGlobalProperties.js';\nimport { SetGlobalPropertiesResponse } from './messages/SetGlobalPropertiesResponse.js';\nimport { ResetGlobalProperties } from './messages/ResetGlobalProperties.js';\nimport { ResetGlobalPropertiesResponse } from './messages/ResetGlobalPropertiesResponse.js';\nimport { AddCommand } from './messages/AddCommand.js';\nimport { AddCommandResponse } from './messages/AddCommandResponse.js';\nimport { DeleteCommand } from './messages/DeleteCommand.js';\nimport { DeleteCommandResponse } from './messages/DeleteCommandResponse.js';\nimport { AddSubMenu } from './messages/AddSubMenu.js';\nimport { AddSubMenuResponse } from './messages/AddSubMenuResponse.js';\nimport { DeleteSubMenu } from './messages/DeleteSubMenu.js';\nimport { DeleteSubMenuResponse } from './messages/DeleteSubMenuResponse.js';\nimport { ShowAppMenu } from './messages/ShowAppMenu.js';\nimport { ShowAppMenuResponse } from './messages/ShowAppMenuResponse.js';\nimport { CreateInteractionChoiceSet } from './messages/CreateInteractionChoiceSet.js';\nimport { CreateInteractionChoiceSetResponse } from './messages/CreateInteractionChoiceSetResponse.js';\nimport { PerformInteraction } from './messages/PerformInteraction.js';\nimport { PerformInteractionResponse } from './messages/PerformInteractionResponse.js';\nimport { DeleteInteractionChoiceSet } from './messages/DeleteInteractionChoiceSet.js';\nimport { DeleteInteractionChoiceSetResponse } from './messages/DeleteInteractionChoiceSetResponse.js';\nimport { Alert } from './messages/Alert.js';\nimport { AlertResponse } from './messages/AlertResponse.js';\nimport { Show } from './messages/Show.js';\nimport { ShowResponse } from './messages/ShowResponse.js';\nimport { Speak } from './messages/Speak.js';\nimport { SpeakResponse } from './messages/SpeakResponse.js';\nimport { SetMediaClockTimer } from './messages/SetMediaClockTimer.js';\nimport { SetMediaClockTimerResponse } from './messages/SetMediaClockTimerResponse.js';\nimport { PerformAudioPassThru } from './messages/PerformAudioPassThru.js';\nimport { PerformAudioPassThruResponse } from './messages/PerformAudioPassThruResponse.js';\nimport { EndAudioPassThru } from './messages/EndAudioPassThru.js';\nimport { EndAudioPassThruResponse } from './messages/EndAudioPassThruResponse.js';\nimport { SubscribeButton } from './messages/SubscribeButton.js';\nimport { SubscribeButtonResponse } from './messages/SubscribeButtonResponse.js';\nimport { UnsubscribeButton } from './messages/UnsubscribeButton.js';\nimport { UnsubscribeButtonResponse } from './messages/UnsubscribeButtonResponse.js';\nimport { SubscribeVehicleData } from './messages/SubscribeVehicleData.js';\nimport { SubscribeVehicleDataResponse } from './messages/SubscribeVehicleDataResponse.js';\nimport { UnsubscribeVehicleData } from './messages/UnsubscribeVehicleData.js';\nimport { UnsubscribeVehicleDataResponse } from './messages/UnsubscribeVehicleDataResponse.js';\nimport { GetVehicleData } from './messages/GetVehicleData.js';\nimport { GetVehicleDataResponse } from './messages/GetVehicleDataResponse.js';\nimport { ReadDID } from './messages/ReadDID.js';\nimport { ReadDIDResponse } from './messages/ReadDIDResponse.js';\nimport { GetDTCs } from './messages/GetDTCs.js';\nimport { GetDTCsResponse } from './messages/GetDTCsResponse.js';\nimport { DiagnosticMessage } from './messages/DiagnosticMessage.js';\nimport { DiagnosticMessageResponse } from './messages/DiagnosticMessageResponse.js';\nimport { ScrollableMessage } from './messages/ScrollableMessage.js';\nimport { ScrollableMessageResponse } from './messages/ScrollableMessageResponse.js';\nimport { Slider } from './messages/Slider.js';\nimport { SliderResponse } from './messages/SliderResponse.js';\nimport { ShowConstantTBT } from './messages/ShowConstantTBT.js';\nimport { ShowConstantTBTResponse } from './messages/ShowConstantTBTResponse.js';\nimport { AlertManeuver } from './messages/AlertManeuver.js';\nimport { AlertManeuverResponse } from './messages/AlertManeuverResponse.js';\nimport { UpdateTurnList } from './messages/UpdateTurnList.js';\nimport { UpdateTurnListResponse } from './messages/UpdateTurnListResponse.js';\nimport { ChangeRegistration } from './messages/ChangeRegistration.js';\nimport { ChangeRegistrationResponse } from './messages/ChangeRegistrationResponse.js';\nimport { GenericResponseResponse } from './messages/GenericResponseResponse.js';\nimport { PutFile } from './messages/PutFile.js';\nimport { PutFileResponse } from './messages/PutFileResponse.js';\nimport { GetFile } from './messages/GetFile.js';\nimport { GetFileResponse } from './messages/GetFileResponse.js';\nimport { DeleteFile } from './messages/DeleteFile.js';\nimport { DeleteFileResponse } from './messages/DeleteFileResponse.js';\nimport { ListFiles } from './messages/ListFiles.js';\nimport { ListFilesResponse } from './messages/ListFilesResponse.js';\nimport { SetAppIcon } from './messages/SetAppIcon.js';\nimport { SetAppIconResponse } from './messages/SetAppIconResponse.js';\nimport { SetDisplayLayout } from './messages/SetDisplayLayout.js';\nimport { SetDisplayLayoutResponse } from './messages/SetDisplayLayoutResponse.js';\nimport { SystemRequest } from './messages/SystemRequest.js';\nimport { SystemRequestResponse } from './messages/SystemRequestResponse.js';\nimport { SendLocation } from './messages/SendLocation.js';\nimport { SendLocationResponse } from './messages/SendLocationResponse.js';\nimport { DialNumber } from './messages/DialNumber.js';\nimport { DialNumberResponse } from './messages/DialNumberResponse.js';\nimport { ButtonPress } from './messages/ButtonPress.js';\nimport { ButtonPressResponse } from './messages/ButtonPressResponse.js';\nimport { GetInteriorVehicleData } from './messages/GetInteriorVehicleData.js';\nimport { GetInteriorVehicleDataResponse } from './messages/GetInteriorVehicleDataResponse.js';\nimport { GetInteriorVehicleDataConsent } from './messages/GetInteriorVehicleDataConsent.js';\nimport { GetInteriorVehicleDataConsentResponse } from './messages/GetInteriorVehicleDataConsentResponse.js';\nimport { ReleaseInteriorVehicleDataModule } from './messages/ReleaseInteriorVehicleDataModule.js';\nimport { ReleaseInteriorVehicleDataModuleResponse } from './messages/ReleaseInteriorVehicleDataModuleResponse.js';\nimport { SetInteriorVehicleData } from './messages/SetInteriorVehicleData.js';\nimport { SetInteriorVehicleDataResponse } from './messages/SetInteriorVehicleDataResponse.js';\nimport { SubscribeWayPoints } from './messages/SubscribeWayPoints.js';\nimport { SubscribeWayPointsResponse } from './messages/SubscribeWayPointsResponse.js';\nimport { GetWayPoints } from './messages/GetWayPoints.js';\nimport { GetWayPointsResponse } from './messages/GetWayPointsResponse.js';\nimport { UnsubscribeWayPoints } from './messages/UnsubscribeWayPoints.js';\nimport { UnsubscribeWayPointsResponse } from './messages/UnsubscribeWayPointsResponse.js';\nimport { GetSystemCapability } from './messages/GetSystemCapability.js';\nimport { GetSystemCapabilityResponse } from './messages/GetSystemCapabilityResponse.js';\nimport { SendHapticData } from './messages/SendHapticData.js';\nimport { SendHapticDataResponse } from './messages/SendHapticDataResponse.js';\nimport { SetCloudAppProperties } from './messages/SetCloudAppProperties.js';\nimport { SetCloudAppPropertiesResponse } from './messages/SetCloudAppPropertiesResponse.js';\nimport { GetCloudAppProperties } from './messages/GetCloudAppProperties.js';\nimport { GetCloudAppPropertiesResponse } from './messages/GetCloudAppPropertiesResponse.js';\nimport { PublishAppService } from './messages/PublishAppService.js';\nimport { PublishAppServiceResponse } from './messages/PublishAppServiceResponse.js';\nimport { UnpublishAppService } from './messages/UnpublishAppService.js';\nimport { UnpublishAppServiceResponse } from './messages/UnpublishAppServiceResponse.js';\nimport { GetAppServiceData } from './messages/GetAppServiceData.js';\nimport { GetAppServiceDataResponse } from './messages/GetAppServiceDataResponse.js';\nimport { PerformAppServiceInteraction } from './messages/PerformAppServiceInteraction.js';\nimport { PerformAppServiceInteractionResponse } from './messages/PerformAppServiceInteractionResponse.js';\nimport { CancelInteraction } from './messages/CancelInteraction.js';\nimport { CancelInteractionResponse } from './messages/CancelInteractionResponse.js';\nimport { CloseApplication } from './messages/CloseApplication.js';\nimport { CloseApplicationResponse } from './messages/CloseApplicationResponse.js';\nimport { OnHMIStatus } from './messages/OnHMIStatus.js';\nimport { OnAppInterfaceUnregistered } from './messages/OnAppInterfaceUnregistered.js';\nimport { OnButtonEvent } from './messages/OnButtonEvent.js';\nimport { OnButtonPress } from './messages/OnButtonPress.js';\nimport { OnVehicleData } from './messages/OnVehicleData.js';\nimport { OnCommand } from './messages/OnCommand.js';\nimport { OnTBTClientState } from './messages/OnTBTClientState.js';\nimport { OnDriverDistraction } from './messages/OnDriverDistraction.js';\nimport { OnPermissionsChange } from './messages/OnPermissionsChange.js';\nimport { OnAudioPassThru } from './messages/OnAudioPassThru.js';\nimport { OnLanguageChange } from './messages/OnLanguageChange.js';\nimport { OnKeyboardInput } from './messages/OnKeyboardInput.js';\nimport { OnTouchEvent } from './messages/OnTouchEvent.js';\nimport { OnSystemRequest } from './messages/OnSystemRequest.js';\nimport { OnHashChange } from './messages/OnHashChange.js';\nimport { OnWayPointChange } from './messages/OnWayPointChange.js';\nimport { OnInteriorVehicleData } from './messages/OnInteriorVehicleData.js';\nimport { OnRCStatus } from './messages/OnRCStatus.js';\nimport { OnAppServiceData } from './messages/OnAppServiceData.js';\nimport { OnSystemCapabilityUpdated } from './messages/OnSystemCapabilityUpdated.js';\nimport { EncodedSyncPData } from './messages/EncodedSyncPData.js';\nimport { EncodedSyncPDataResponse } from './messages/EncodedSyncPDataResponse.js';\nimport { OnEncodedSyncPData } from './messages/OnEncodedSyncPData.js';\n\n// other\nimport { RpcType } from './enums/RpcType.js';\nimport { FunctionID } from './enums/FunctionID.js';\nimport { JsonRpcMarshaller } from './../util/JsonRpcMarshaller.js';\nimport { BinaryFrameHeader } from './../protocol/BinaryFrameHeader.js';\n\nclass RpcCreator {\n    /**\n     * Converts an SdlPacket to an RpcMessage\n     * @param {SdlPacket} sdlPacket\n     * @return {RpcMessage}\n     */\n    static construct (sdlPacket) {\n        const payload = sdlPacket.getPayload();\n        const binaryFrameHeader = BinaryFrameHeader.fromBinaryHeader(payload);\n\n        let message;\n        const rpcType = binaryFrameHeader.getRpcType();\n        const rpcName = RpcType.keyForValue(rpcType);\n        const correlationId = binaryFrameHeader.getCorrelationId();\n        const functionId = binaryFrameHeader.getFunctionId();\n        const functionName = FunctionID.keyForValue(functionId);\n        const bulkData = binaryFrameHeader.getBulkData();\n        const jsonData = binaryFrameHeader.getJsonData();\n        const params = {\n            parameters: JsonRpcMarshaller.unmarshall(jsonData),\n        };\n\n        switch (functionId) {\n            case FunctionID.RegisterAppInterface:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new RegisterAppInterface(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new RegisterAppInterfaceResponse(params);\n                }\n                break;\n            case FunctionID.UnregisterAppInterface:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new UnregisterAppInterface(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new UnregisterAppInterfaceResponse(params);\n                }\n                break;\n            case FunctionID.CreateWindow:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new CreateWindow(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new CreateWindowResponse(params);\n                }\n                break;\n            case FunctionID.DeleteWindow:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new DeleteWindow(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new DeleteWindowResponse(params);\n                }\n                break;\n            case FunctionID.SetGlobalProperties:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SetGlobalProperties(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SetGlobalPropertiesResponse(params);\n                }\n                break;\n            case FunctionID.ResetGlobalProperties:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ResetGlobalProperties(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ResetGlobalPropertiesResponse(params);\n                }\n                break;\n            case FunctionID.AddCommand:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new AddCommand(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new AddCommandResponse(params);\n                }\n                break;\n            case FunctionID.DeleteCommand:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new DeleteCommand(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new DeleteCommandResponse(params);\n                }\n                break;\n            case FunctionID.AddSubMenu:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new AddSubMenu(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new AddSubMenuResponse(params);\n                }\n                break;\n            case FunctionID.DeleteSubMenu:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new DeleteSubMenu(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new DeleteSubMenuResponse(params);\n                }\n                break;\n            case FunctionID.ShowAppMenu:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ShowAppMenu(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ShowAppMenuResponse(params);\n                }\n                break;\n            case FunctionID.CreateInteractionChoiceSet:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new CreateInteractionChoiceSet(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new CreateInteractionChoiceSetResponse(params);\n                }\n                break;\n            case FunctionID.PerformInteraction:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new PerformInteraction(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new PerformInteractionResponse(params);\n                }\n                break;\n            case FunctionID.DeleteInteractionChoiceSet:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new DeleteInteractionChoiceSet(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new DeleteInteractionChoiceSetResponse(params);\n                }\n                break;\n            case FunctionID.Alert:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new Alert(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new AlertResponse(params);\n                }\n                break;\n            case FunctionID.Show:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new Show(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ShowResponse(params);\n                }\n                break;\n            case FunctionID.Speak:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new Speak(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SpeakResponse(params);\n                }\n                break;\n            case FunctionID.SetMediaClockTimer:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SetMediaClockTimer(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SetMediaClockTimerResponse(params);\n                }\n                break;\n            case FunctionID.PerformAudioPassThru:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new PerformAudioPassThru(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new PerformAudioPassThruResponse(params);\n                }\n                break;\n            case FunctionID.EndAudioPassThru:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new EndAudioPassThru(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new EndAudioPassThruResponse(params);\n                }\n                break;\n            case FunctionID.SubscribeButton:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SubscribeButton(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SubscribeButtonResponse(params);\n                }\n                break;\n            case FunctionID.UnsubscribeButton:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new UnsubscribeButton(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new UnsubscribeButtonResponse(params);\n                }\n                break;\n            case FunctionID.SubscribeVehicleData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SubscribeVehicleData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SubscribeVehicleDataResponse(params);\n                }\n                break;\n            case FunctionID.UnsubscribeVehicleData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new UnsubscribeVehicleData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new UnsubscribeVehicleDataResponse(params);\n                }\n                break;\n            case FunctionID.GetVehicleData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetVehicleData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetVehicleDataResponse(params);\n                }\n                break;\n            case FunctionID.ReadDID:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ReadDID(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ReadDIDResponse(params);\n                }\n                break;\n            case FunctionID.GetDTCs:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetDTCs(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetDTCsResponse(params);\n                }\n                break;\n            case FunctionID.DiagnosticMessage:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new DiagnosticMessage(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new DiagnosticMessageResponse(params);\n                }\n                break;\n            case FunctionID.ScrollableMessage:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ScrollableMessage(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ScrollableMessageResponse(params);\n                }\n                break;\n            case FunctionID.Slider:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new Slider(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SliderResponse(params);\n                }\n                break;\n            case FunctionID.ShowConstantTBT:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ShowConstantTBT(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ShowConstantTBTResponse(params);\n                }\n                break;\n            case FunctionID.AlertManeuver:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new AlertManeuver(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new AlertManeuverResponse(params);\n                }\n                break;\n            case FunctionID.UpdateTurnList:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new UpdateTurnList(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new UpdateTurnListResponse(params);\n                }\n                break;\n            case FunctionID.ChangeRegistration:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ChangeRegistration(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ChangeRegistrationResponse(params);\n                }\n                break;\n            case FunctionID.GenericResponse:\n                if (rpcType === RpcType.RESPONSE) {\n                    message = new GenericResponseResponse(params);\n                }\n                break;\n            case FunctionID.PutFile:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new PutFile(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new PutFileResponse(params);\n                }\n                break;\n            case FunctionID.GetFile:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetFile(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetFileResponse(params);\n                }\n                break;\n            case FunctionID.DeleteFile:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new DeleteFile(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new DeleteFileResponse(params);\n                }\n                break;\n            case FunctionID.ListFiles:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ListFiles(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ListFilesResponse(params);\n                }\n                break;\n            case FunctionID.SetAppIcon:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SetAppIcon(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SetAppIconResponse(params);\n                }\n                break;\n            case FunctionID.SetDisplayLayout:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SetDisplayLayout(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SetDisplayLayoutResponse(params);\n                }\n                break;\n            case FunctionID.SystemRequest:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SystemRequest(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SystemRequestResponse(params);\n                }\n                break;\n            case FunctionID.SendLocation:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SendLocation(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SendLocationResponse(params);\n                }\n                break;\n            case FunctionID.DialNumber:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new DialNumber(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new DialNumberResponse(params);\n                }\n                break;\n            case FunctionID.ButtonPress:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ButtonPress(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ButtonPressResponse(params);\n                }\n                break;\n            case FunctionID.GetInteriorVehicleData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetInteriorVehicleData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetInteriorVehicleDataResponse(params);\n                }\n                break;\n            case FunctionID.GetInteriorVehicleDataConsent:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetInteriorVehicleDataConsent(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetInteriorVehicleDataConsentResponse(params);\n                }\n                break;\n            case FunctionID.ReleaseInteriorVehicleDataModule:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new ReleaseInteriorVehicleDataModule(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new ReleaseInteriorVehicleDataModuleResponse(params);\n                }\n                break;\n            case FunctionID.SetInteriorVehicleData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SetInteriorVehicleData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SetInteriorVehicleDataResponse(params);\n                }\n                break;\n            case FunctionID.SubscribeWayPoints:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SubscribeWayPoints(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SubscribeWayPointsResponse(params);\n                }\n                break;\n            case FunctionID.GetWayPoints:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetWayPoints(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetWayPointsResponse(params);\n                }\n                break;\n            case FunctionID.UnsubscribeWayPoints:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new UnsubscribeWayPoints(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new UnsubscribeWayPointsResponse(params);\n                }\n                break;\n            case FunctionID.GetSystemCapability:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetSystemCapability(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetSystemCapabilityResponse(params);\n                }\n                break;\n            case FunctionID.SendHapticData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SendHapticData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SendHapticDataResponse(params);\n                }\n                break;\n            case FunctionID.SetCloudAppProperties:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new SetCloudAppProperties(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new SetCloudAppPropertiesResponse(params);\n                }\n                break;\n            case FunctionID.GetCloudAppProperties:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetCloudAppProperties(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetCloudAppPropertiesResponse(params);\n                }\n                break;\n            case FunctionID.PublishAppService:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new PublishAppService(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new PublishAppServiceResponse(params);\n                }\n                break;\n            case FunctionID.UnpublishAppService:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new UnpublishAppService(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new UnpublishAppServiceResponse(params);\n                }\n                break;\n            case FunctionID.GetAppServiceData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new GetAppServiceData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new GetAppServiceDataResponse(params);\n                }\n                break;\n            case FunctionID.PerformAppServiceInteraction:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new PerformAppServiceInteraction(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new PerformAppServiceInteractionResponse(params);\n                }\n                break;\n            case FunctionID.CancelInteraction:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new CancelInteraction(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new CancelInteractionResponse(params);\n                }\n                break;\n            case FunctionID.CloseApplication:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new CloseApplication(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new CloseApplicationResponse(params);\n                }\n                break;\n            case FunctionID.OnHMIStatus:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnHMIStatus(params);\n                }\n                break;\n            case FunctionID.OnAppInterfaceUnregistered:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnAppInterfaceUnregistered(params);\n                }\n                break;\n            case FunctionID.OnButtonEvent:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnButtonEvent(params);\n                }\n                break;\n            case FunctionID.OnButtonPress:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnButtonPress(params);\n                }\n                break;\n            case FunctionID.OnVehicleData:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnVehicleData(params);\n                }\n                break;\n            case FunctionID.OnCommand:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnCommand(params);\n                }\n                break;\n            case FunctionID.OnTBTClientState:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnTBTClientState(params);\n                }\n                break;\n            case FunctionID.OnDriverDistraction:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnDriverDistraction(params);\n                }\n                break;\n            case FunctionID.OnPermissionsChange:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnPermissionsChange(params);\n                }\n                break;\n            case FunctionID.OnAudioPassThru:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnAudioPassThru(params);\n                }\n                break;\n            case FunctionID.OnLanguageChange:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnLanguageChange(params);\n                }\n                break;\n            case FunctionID.OnKeyboardInput:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnKeyboardInput(params);\n                }\n                break;\n            case FunctionID.OnTouchEvent:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnTouchEvent(params);\n                }\n                break;\n            case FunctionID.OnSystemRequest:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnSystemRequest(params);\n                }\n                break;\n            case FunctionID.OnHashChange:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnHashChange(params);\n                }\n                break;\n            case FunctionID.OnWayPointChange:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnWayPointChange(params);\n                }\n                break;\n            case FunctionID.OnInteriorVehicleData:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnInteriorVehicleData(params);\n                }\n                break;\n            case FunctionID.OnRCStatus:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnRCStatus(params);\n                }\n                break;\n            case FunctionID.OnAppServiceData:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnAppServiceData(params);\n                }\n                break;\n            case FunctionID.OnSystemCapabilityUpdated:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnSystemCapabilityUpdated(params);\n                }\n                break;\n            case FunctionID.EncodedSyncPData:\n                if (rpcType === RpcType.REQUEST) {\n                    message = new EncodedSyncPData(params);\n                } else if (rpcType === RpcType.RESPONSE) {\n                    message = new EncodedSyncPDataResponse(params);\n                }\n                break;\n            case FunctionID.OnEncodedSyncPData:\n                if (rpcType === RpcType.NOTIFICATION) {\n                    message = new OnEncodedSyncPData(params);\n                }\n                break;\n            default:\n                message = null;\n        }\n\n        if (message === null || message === undefined) { // informs of missing classes\n            console.warn(`RpcCreator couldn't construct an RPC for the ${functionName} ${rpcName}`);\n            return null;\n        }\n\n        if (rpcType === RpcType.REQUEST || rpcType === RpcType.RESPONSE) {\n            message.setCorrelationId(correlationId);\n        }\n        if (bulkData) {\n            message.setBulkData(bulkData);\n        }\n\n        return message;\n    }\n}\n\n\nexport { RpcCreator };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { MessageFrameDisassembler } from './MessageFrameDisassembler.js';\nimport { TransportListener } from '../transport/TransportListener.js';\nimport { Version } from '../util/Version.js';\nimport { ServiceType } from './enums/ServiceType.js';\nimport { FrameType } from './enums/FrameType.js';\nimport { MessageFrameAssembler } from './MessageFrameAssembler.js';\nimport { SdlPacket } from './SdlPacket.js';\nimport { ControlFrameTags } from './enums/ControlFrameTags.js';\nimport { BitConverter } from './../util/BitConverter.js';\n\nimport { SdlPacketFactory } from './SdlPacketFactory.js';\nimport { RpcCreator } from './../rpc/RpcCreator.js';\nimport { ImageResolution } from '../rpc/structs/ImageResolution.js';\nimport { VideoStreamingFormat } from '../rpc/structs/VideoStreamingFormat.js';\n\n/**\n * Base implementation of sdl protocol.\n * Should be able to handle basic control frames and be able to\n * send and receive packets from the transport manager.\n * Also sends key events to the sdlProtocolListener.\n */\nclass SdlProtocolBase {\n    /**\n     *\n     * @param { TransportConfigBase } baseTransportConfig\n     * @param { SdlProtocolListener } sdlProtocolListener\n     * @constructor\n     */\n    constructor (baseTransportConfig, sdlProtocolListener) {\n        this._baseTransportConfig = baseTransportConfig;\n        this._transportConfig = baseTransportConfig;\n        this._sdlProtocolListener = sdlProtocolListener;\n        this._transportManager = null;\n\n        this._reset();\n        this._createTransportListener();\n    }\n\n\n    /**\n     * Resets the sdl protocol to its default state.\n     * @private\n     */\n    _reset () {\n        this._protocolVersion = new Version(1, 0, 0);\n        this._transportConfig = this._baseTransportConfig;\n        this._headerSize = SdlProtocolBase.V1_HEADER_SIZE;\n        this._serviceStatus = {};\n        this._serviceStatus[ServiceType.CONTROL] = true;\n        this._mtus = {};\n        this._mtus[ServiceType.RPC] = SdlProtocolBase.V1_V2_MTU_SIZE - this._headerSize;\n        this._hashID = 0;\n        this._messageFrameAssemblers = {};\n        this._messageID = 1;\n        this._sessionID = 0;\n    }\n\n\n    /**\n     * Sets a transport manager.\n     * @param { TransportManagerBase } manager\n     */\n    setTransportManager (manager) {\n        if (!this._serviceStatus[ServiceType.RPC]) {\n            // RPC service hasn't been started, lets start it\n            this.startService(ServiceType.RPC, 0, false);\n        }\n        this._transportManager = manager;\n    }\n\n\n    /**\n     * Creates the transport listener. This will recieve incoming requests\n     * from the transport manager.\n     */\n    _createTransportListener () {\n        const self = this;\n        this._transportListener = new TransportListener();\n        this._transportListener.setOnTransportConnected(function () {\n            self._handleTransportConnected();\n        });\n        this._transportListener.setOnTransportDisconnected(function () {\n        });\n        this._transportListener.setOnPacketReceived(function (sdlPacket) {\n            self._handlePacketReceived(sdlPacket);\n        });\n        this._transportListener.setOnError(function () {\n        });\n    }\n\n    _handleTransportConnected () {\n        this._sdlProtocolListener.onTransportConnected();\n    }\n\n    /**\n     * Starts up the SDL protocol class. It will kick off the transport manager and underlying transport.\n     */\n    start () {\n        if (!this._transportManager) {\n            throw new Error('A transport manager must be defined, unable to start SDL Protocol');\n        }\n        this._transportManager.start();\n    }\n\n\n    /**\n     * Start the service. This is the first step in communicating with sdl core.\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID\n     * @param {Boolean} isEncrypted\n     */\n    startService (serviceType, sessionID, isEncrypted) {\n        const protocolVersion = this.constructor.MAX_PROTOCOL_VERSION;\n        const messageID = 0;\n        const header = new SdlPacket(protocolVersion.getMajor(), isEncrypted, FrameType.CONTROL,\n            serviceType, SdlPacket.FRAME_INFO_START_SERVICE, sessionID,\n            0, messageID, null);\n        if (serviceType === ServiceType.AUDIO) {\n            return this.sendPacket(header);\n        } else if (serviceType === ServiceType.RPC) {\n            header.putTag(ControlFrameTags.RPC.StartService.PROTOCOL_VERSION, protocolVersion.toString());\n        } else if (serviceType === ServiceType.VIDEO) {\n            if (this._sdlProtocolListener !== null) {\n                const videoStreamingParameters = this._sdlProtocolListener.getDesiredVideoParams();\n                if (videoStreamingParameters !== null) {\n                    const desiredResolution = videoStreamingParameters.getResolution();\n                    const desiredFormat = videoStreamingParameters.getFormat();\n                    if (desiredResolution) {\n                        header.putTag(ControlFrameTags.Video.StartService.WIDTH, desiredResolution.getResolutionWidth());\n                        header.putTag(ControlFrameTags.Video.StartService.HEIGHT, desiredResolution.getResolutionHeight());\n                    }\n                    if (desiredFormat) {\n                        header.putTag(ControlFrameTags.Video.StartService.VIDEO_CODEC, desiredFormat.getCodec());\n                        header.putTag(ControlFrameTags.Video.StartService.VIDEO_PROTOCOL, desiredFormat.getProtocol());\n                    }\n                }\n            }\n            return this.sendPacket(header);\n        } else {\n            throw new Error('Service type not implemented');\n        }\n        this.sendPacket(header);\n    }\n\n    /**\n     *  Get the max transport unit of a specific service type.\n     * @param { ServiceType } serviceType\n     * @return {number} max transport unit for the given service type\n     */\n    getMtu (serviceType) {\n        const retVal = this._mtus[serviceType];\n        if (retVal) {\n            return retVal;\n        }\n        return SdlProtocolBase.V1_V2_MTU_SIZE;\n    }\n\n    /**\n     * Returns true if transport manager is connected.\n     * @return {Boolean} isConnected\n     */\n    isConnected () {\n        return this._transportManager && this._transportManager.isConnected(null, null);\n    }\n\n    /**\n     * Get the current protocol version in use.\n     * @returns {Version} protocol version\n     */\n    getProtocolVersion () {\n        return this._protocolVersion;\n    }\n\n\n    /**\n     * This method will set the major protocol version that we should use.\n     * It will also set the default MTU based on version.\n     * @param { number } version major version to use\n     */\n    _setVersion (version) {\n        if (version > 5) {\n            this._protocolVersion = new Version('5.1.0'); // protect for future, proxy only supports v5 or lower\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE;\n        } else if (version === 5) {\n            this._protocolVersion = new Version('5.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE;\n        } else if (version === 4) {\n            this._protocolVersion = new Version('4.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE; // versions 4 supports 128k MTU\n        } else if (version === 3) {\n            this._protocolVersion = new Version('3.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V3_V4_MTU_SIZE; // versions 3 supports 128k MTU\n        } else if (version === 2) {\n            this._protocolVersion = new Version('2.0.0');\n            this.headerSize = this.constructor.V2_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V1_V2_MTU_SIZE - this.headerSize;\n        } else if (version === 1) {\n            this._protocolVersion = new Version('1.0.0');\n            this.headerSize = this.constructor.V1_HEADER_SIZE;\n            this._mtus[ServiceType.RPC] = this.constructor.V1_V2_MTU_SIZE - this.headerSize;\n        }\n    }\n\n    /**\n     * Sends an sdlPacket.\n     * @param {SdlPacket} sdlPacket\n     */\n    sendPacket (sdlPacket) {\n        if (this._transportManager) {\n            this._transportManager.sendPacket(sdlPacket);\n        }\n    }\n\n    /**\n     * Returns the sessionId in use.\n     * @returns {Number}\n     */\n    _getSessionId () {\n        return this._sdlProtocolListener.getSessionId();\n    }\n\n    /**\n     * Gets the next available messageID for sending requests.\n     * @returns {Number}\n     */\n    _getNextMessageID () {\n        return this._messageID++;\n    }\n\n    /**\n     * Takes an rpc message and sends a single or multi frame packets.\n     * @param {RpcRequest} rpcMessage\n     */\n    sendRpc (rpcRequest) {\n        const self = this;\n        const sessionId = this._getSessionId();\n        const messageID = this._getNextMessageID();\n        const mtu = self._mtus[ServiceType.RPC];\n        const version = self._protocolVersion.getMajor();\n        const isEncrypted = rpcRequest.getIsEncrypted();\n\n        MessageFrameDisassembler.buildRPC(rpcRequest, sessionId, messageID, mtu, version, isEncrypted, function (sdlPacket) {\n            self.sendPacket(sdlPacket);\n        });\n    }\n\n    /**\n     * Handles incoming packets.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handlePacketReceived (sdlPacket) {\n        if (this._protocolVersion === null || this._protocolVersion.getMajor() === 1) {\n            this._setVersion(sdlPacket.getVersion());\n        }\n        const frameType = sdlPacket.getFrameType();\n        if (frameType === FrameType.CONTROL) {\n            return this._handleControlPacket(sdlPacket);\n        } else {\n            const messageFrameAssembler = this._getMessageFrameAssembler(sdlPacket);\n            return messageFrameAssembler.handleFrame(sdlPacket);\n        }\n    }\n\n    /**\n     * Handles non-control packets after they have been assembled.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleOnMessageAssembled (sdlPacket) {\n        const serviceType = sdlPacket.getServiceType();\n\n        if (serviceType === ServiceType.RPC || serviceType === ServiceType.HYBRID) {\n            return this._handleRPCPacket(sdlPacket);\n        } else if (serviceType === ServiceType.HYBRID) {\n            return this._handleRPCPacket(sdlPacket);\n        } else {\n            console.warn('Unhandled service type ', sdlPacket);\n        }\n    }\n\n    /**\n     * Get the message frame assembler for the packet.\n     * @param {SdlPacket} sdlPacket\n     */\n    _getMessageFrameAssembler (sdlPacket) {\n        const self = this;\n        let messageFrameAssembler = self._messageFrameAssemblers[sdlPacket.getMessageID()];\n        if (!messageFrameAssembler) {\n            messageFrameAssembler = new MessageFrameAssembler(function (err, sdlPacket) {\n                if (err) {\n                    throw new Error(err);\n                }\n                self._messageFrameAssemblers[sdlPacket.getMessageID()] = null; // Remove the mapping\n                self._handleOnMessageAssembled(sdlPacket);\n            });\n            self._messageFrameAssemblers[sdlPacket.getMessageID()] = messageFrameAssembler;\n        }\n\n        return messageFrameAssembler;\n    }\n\n    /**\n     * Handles incoming control packets.\n     * @param { SdlPacket } sdlPacket\n     */\n    _handleControlPacket (sdlPacket) {\n        const frameInfo = sdlPacket.getFrameInfo();\n\n        if (frameInfo === SdlPacket.FRAME_INFO_HEART_BEAT) {\n            return this._handleProtocolHeartbeat(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_HEART_BEAT_ACK) {\n            return this._handleProtocolHeartbeatACK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_START_SERVICE_ACK) {\n            return this._handleStartServiceACK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_START_SERVICE_NAK) {\n            return this._handleStartServiceNAK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_END_SERVICE_ACK) {\n            return this._handleEndServiceACK(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_END_SERVICE) {\n            return this._handleEndService(sdlPacket);\n        } else if (frameInfo === SdlPacket.FRAME_INFO_END_SERVICE_NAK) {\n            return this._handleEndServiceNAK(sdlPacket);\n        } else {\n            console.warn('Unhandled control packet', { frameInfo });\n        }\n    }\n\n\n    /**\n     * Handle heartbeat (Only available in protocol version 3)\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleProtocolHeartbeat (sdlPacket) {\n        const heartbeat = SdlPacketFactory.createHeartbeatACK(\n            ServiceType.CONTROL,\n            this._getSessionId(),\n            this._protocolVersion.getMajor());\n        this.sendPacket(heartbeat);\n    }\n\n    /**\n     * Handles heartbeat ACK.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleProtocolHeartbeatACK (sdlPacket) {\n        console.log(`Received HeartbeatACK - ${sdlPacket.toString()}`);\n    }\n\n    /**\n     * Handles start service ACK. Sets the appropriate version, MTU, and other\n     * service related info.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleStartServiceACK (sdlPacket) {\n        const version = sdlPacket.getVersion();\n        const serviceType = sdlPacket.getServiceType();\n        if (version >= 5) {\n            let mtuTag = null;\n            if (serviceType === ServiceType.RPC) {\n                mtuTag = ControlFrameTags.RPC.StartServiceACK.MTU;\n            } else if (serviceType === (ServiceType.PCM)) {\n                mtuTag = ControlFrameTags.Audio.StartServiceACK.MTU;\n            } else if (serviceType === (ServiceType.NAV)) {\n                mtuTag = ControlFrameTags.Video.StartServiceACK.MTU;\n            }\n            const mtu = sdlPacket.getTag(mtuTag);\n\n            if (mtu !== null) {\n                this._mtus[serviceType] = mtu;\n            }\n            if (serviceType === ServiceType.RPC) {\n                this._sessionID = sdlPacket.getSessionID();\n                // TODO handle older versions of the protocol where this was just their payload, no BSON\n                this._hashID = sdlPacket.getTag(ControlFrameTags.RPC.StartServiceACK.HASH_ID);\n                const version = sdlPacket.getTag(ControlFrameTags.RPC.StartServiceACK.PROTOCOL_VERSION);\n                if (version) {\n                    // At this point we have confirmed the negotiated version between the module and the proxy\n                    this._protocolVersion = (new Version()).fromString(version);\n                } else {\n                    this._protocolVersion = new Version(5, 0, 0);\n                }\n            } else if (serviceType === ServiceType.VIDEO) {\n                if (this._sdlProtocolListener !== null) {\n                    const acceptedResolution = new ImageResolution();\n                    const acceptedFormat = new VideoStreamingFormat();\n                    acceptedResolution.setResolutionHeight(Math.floor(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.HEIGHT)));\n                    acceptedResolution.setResolutionWidth(Math.floor(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.WIDTH)));\n\n                    acceptedFormat.setCodec(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.VIDEO_CODEC));\n                    acceptedFormat.setProtocol(sdlPacket.getTag(ControlFrameTags.Video.StartServiceACK.VIDEO_PROTOCOL));\n                    const agreedVideoParams = this._sdlProtocolListener.getDesiredVideoParams();\n                    agreedVideoParams.setResolution(acceptedResolution);\n                    agreedVideoParams.setFormat(acceptedFormat);\n\n                    this._sdlProtocolListener.setAcceptedVideoParams(agreedVideoParams);\n                }\n            }\n        } else {\n            if (this._protocolVersion.getMajor() > 1) {\n                const payload = sdlPacket.getPayload();\n                if (payload !== null && payload.length === 4) { // hashid will be 4 bytes in length\n                    this._hashID = BitConverter.arrayBufferToInt32(payload.buffer);\n                }\n            }\n        }\n\n        this._sdlProtocolListener.onProtocolSessionStarted(serviceType,\n            sdlPacket.getSessionID(), this._protocolVersion.getMajor(), '', this._hashID, sdlPacket.getEncryption());\n    }\n\n    /**\n     * Handles start service rejection.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleStartServiceNAK (sdlPacket) {\n        const error = `Got StartSessionNACK for protocol sessionID ${sdlPacket.getSessionID()}`;\n        throw new Error(error);\n    }\n\n\n    /**\n     * Handles service ended by app process.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleEndServiceACK (sdlPacket) {\n        return this._handleServiceEnded(sdlPacket);\n    }\n\n    /**\n     * Service ended by non app process or for some unexpected reason.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleEndService (sdlPacket) {\n        return this._handleServiceEnded(sdlPacket);\n    }\n\n\n    /**\n     * Handles serivce ending.\n     * @param {*} sdlPacket\n     */\n    _handleServiceEnded (sdlPacket) {\n        this._sdlProtocolListener.onProtocolSessionEnded(sdlPacket.getServiceType(), sdlPacket.getSessionID(), '');\n    }\n\n    /**\n     * Handles service end rejection.\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleEndServiceNAK (sdlPacket) {\n        const serviceType = sdlPacket.getServiceType();\n        const protocolVersion = sdlPacket.getVersion();\n        if (protocolVersion >= 5) {\n            let rejectedTag = null;\n            if (serviceType === ServiceType.AUDIO) {\n                rejectedTag = ControlFrameTags.Audio.EndServiceNAK.REJECTED_PARAMS;\n            } else if (serviceType === ServiceType.VIDEO) {\n                rejectedTag = ControlFrameTags.Video.EndServiceNAK.REJECTED_PARAMS;\n            }\n            const rejectedParams = sdlPacket.getTag(rejectedTag);\n            if (Array.isArray(rejectedParams) && rejectedParams.length > 0) {\n                console.error('Got EndSessionNAK with rejected params', rejectedParams);\n            }\n        }\n        this._sdlProtocolListener.onProtocolSessionEndedNACKed(serviceType, sdlPacket.getSessionID(), '');\n    }\n\n    /**\n     * Handles incoming assembled rpc packet.\n     * Notifies sdlProtocolListener of the event after assembleing an RpcMessage\n     * @param {SdlPacket} sdlPacket\n     */\n    _handleRPCPacket (sdlPacket) {\n        const rpcMessage = RpcCreator.construct(sdlPacket);\n        if (rpcMessage !== null) {\n            this._sdlProtocolListener.onRpcMessageReceived(rpcMessage);\n        }\n    }\n\n    /**\n     * Ends the default session.\n     */\n    endSession () {\n        const sessionId = this._getSessionId();\n        const hashID = this._hashID;\n        const serviceType = ServiceType.RPC;\n        const messageID = this._getNextMessageID();\n        const version = this._protocolVersion.getMajor();\n        const sdlPacket = SdlPacketFactory.createEndSession(serviceType, sessionId, messageID, version, hashID);\n        this.sendPacket(sdlPacket);\n    }\n\n    /**\n     * Ends a specific service\n     * @param {ServiceType} serviceType - Service type being ended. When the RPC service is ended the entire session ends.\n     * @param {Number} sessionId - represents a byte\n     */\n    endService (serviceType, sessionId) {\n        if (serviceType === ServiceType.RPC) {\n            return this.endSession();\n        } else {\n            const hashID = this._hashID;\n            const messageID = this._getNextMessageID();\n            const version = this._protocolVersion.getMajor();\n            const sdlPacket = SdlPacketFactory.createEndSession(serviceType, sessionId, messageID, version, hashID);\n            this.sendPacket(sdlPacket);\n        }\n    }\n}\n\n/**\n * Original header size based on version 1.0.0 only\n */\nSdlProtocolBase.V1_HEADER_SIZE = 8;\n/**\n * Larger header size that is used by versions 2.0.0 and up\n */\nSdlProtocolBase.V2_HEADER_SIZE = 12;\n\nSdlProtocolBase.V1_V2_MTU_SIZE = 1500;\nSdlProtocolBase.V3_V4_MTU_SIZE = 131072;\n\n/**\n * Max supported protocol version in this release of the library\n*/\nSdlProtocolBase.MAX_PROTOCOL_VERSION = new Version(5, 2, 0);\n\nexport { SdlProtocolBase };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TransportType\n * @property {Object} _MAP\n */\nclass TransportType extends Enum {\n    /**\n    * @constructor\n    */\n    constructor () {\n        super();\n    }\n\n    /**\n    * @param {String}\n    */\n    static get WEBSOCKET_CLIENT () {\n        return TransportType._MAP.WEBSOCKET_CLIENT;\n    }\n\n    /**\n    * @param {String}\n    */\n    static get WEBSOCKET_SERVER () {\n        return TransportType._MAP.WEBSOCKET_SERVER;\n    }\n\n    /**\n    * @param {String}\n    */\n    static get CUSTOM () {\n        return TransportType._MAP.CUSTOM;\n    }\n\n    /**\n    * Get the value for the given enum key\n    * @param value - A key to find in the map of the subclass\n    * @return {*} - Returns a value if found, or null if not found\n    */\n    static valueForKey (key) {\n        return TransportType._valueForKey(key, TransportType._MAP);\n    }\n\n    /**\n    * Get the key for the given enum value\n    * @param value - A primitive value to find the matching key for in the map of the subclass\n    * @return {*} - Returns a key if found, or null if not found\n    */\n    static keyForValue (value) {\n        return TransportType._keyForValue(value, TransportType._MAP);\n    }\n}\n\nTransportType._MAP = Object.freeze({\n    'WEBSOCKET_CLIENT': 'WEBSOCKET_CLIENT',\n    'WEBSOCKET_SERVER': 'WEBSOCKET_SERVER',\n    'CUSTOM': 'CUSTOM',\n});\n\nexport { TransportType };","/*\n * Copyright (c) 2019, Livio, Inc.\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided with the\n * distribution.\n *\n * Neither the name of the Livio Inc. nor the names of its contributors\n * may be used to endorse or promote products derived from this software\n * without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport { FrameType } from '../protocol/enums/FrameType.js';\nimport { SdlPacket } from '../protocol/SdlPacket.js';\nimport { SdlProtocolBase } from '../protocol/SdlProtocolBase.js';\n\n/**\n * Parses incoming bytes according to the protocol spec.\n */\nclass SdlPsm {\n    /**\n     * @constructor\n     */\n    constructor () {\n        this.reset();\n    }\n\n    /**\n     * Changes all internal members to default\n     */\n    reset () {\n        this._state = SdlPsm.START_STATE;\n        this._version = 0;\n        this._encryption = false;\n        this._frameType = FrameType.SINGLE;\n        this._serviceType = 0;\n        this._controlFrameInfo = null;\n        this._sessionID = null;\n        this._dumpSize = null;\n        this._dataLength = 0;\n        this._messageID = 0;\n        this._payload = null;\n    }\n\n\n\n    /**\n     * @return {Number} - State represented by a Number\n     */\n    getState () {\n        return this._state;\n    }\n\n    /**\n     * @return {SdlPacket} - Returns null if not complete\n     */\n\n    getFormedPacket () {\n        if (this._state === SdlPsm.FINISHED_STATE) {\n            return new SdlPacket(this._version, this._encryption, this._frameType, this._serviceType, this._controlFrameInfo, this._sessionID, this._dataLength, this._messageID, this._payload, 0, this._dataLength);\n        } else {\n            return null;\n        }\n    }\n\n    /**\n     * Handles the next byte in the stream of data.\n     * @param {Number} data - Represents a byte\n     * @return {Boolean} - True if successful, false otherwise\n     */\n    handleByte (data) {\n        this._state = this._transitionOnInput(data, this._state);\n        if (this._state === SdlPsm.ERROR_STATE) {\n            return false;\n        }\n        return true;\n    }\n\n    /**\n     * @param {Number} rawByte - Represents a byte\n     * @param {Number} state\n     * @return {Boolean}\n     * @private\n     */\n    _transitionOnInput (rawByte, state) {\n        if (state === SdlPsm.START_STATE) { // byte 1\n            this._version = (rawByte & SdlPsm.VERSION_MASK) >> 4;\n            if (this._version === 0) {\n                return SdlPsm.ERROR_STATE;\n            }\n\n            this._encryption = (1 === ((rawByte & SdlPsm.ENCRYPTION_MASK) >> 3));\n            this._frameType = rawByte & SdlPsm.FRAME_TYPE_MASK;\n\n            if ((this._version < 1 || this._version > 5) && this._frameType !== FrameType.CONTROL) {\n                return SdlPsm.ERROR_STATE;\n            }\n\n            if (this._frameType < FrameType.CONTROL || this._frameType > FrameType.CONSECUTIVE) {\n                return SdlPsm.ERROR_STATE;\n            }\n            return SdlPsm.SERVICE_TYPE_STATE;\n        } else if (state === SdlPsm.SERVICE_TYPE_STATE) { // byte 2\n            this._serviceType = (rawByte & 0xFF);\n\n            return SdlPsm.CONTROL_FRAME_INFO_STATE;\n        } else if (state === SdlPsm.CONTROL_FRAME_INFO_STATE) { // byte 3\n            this._controlFrameInfo = rawByte & 0xFF;\n\n            switch (this._frameType) {\n                case FrameType.CONTROL:\n                    break;\n                case FrameType.SINGLE: // Fall through since they are both the same\n                case FrameType.FIRST:\n                    if (this._controlFrameInfo !== 0x00) {\n                        return SdlPsm.ERROR_STATE;\n                    }\n                    break;\n                case FrameType.CONSECUTIVE:\n                    break;\n\n                default:\n                    return SdlPsm.ERROR_STATE;\n            }\n            return SdlPsm.SESSION_ID_STATE;\n        } else if (state === SdlPsm.SESSION_ID_STATE) { // byte 4\n            this._sessionID = (rawByte & 0xFF);\n            return SdlPsm.DATA_SIZE_1_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_1_STATE) { // byte 5\n            this._dataLength += (rawByte & 0xFF) << 24;\n            return SdlPsm.DATA_SIZE_2_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_2_STATE) { // byte 6\n            this._dataLength += (rawByte & 0xFF) << 16; // # 2 bytes x 8 bits\n            return SdlPsm.DATA_SIZE_3_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_3_STATE) { // byte 7\n            this._dataLength += (rawByte & 0xFF) << 8; // #  1 byte x 8 bits\n            return SdlPsm.DATA_SIZE_4_STATE;\n        } else if (state === SdlPsm.DATA_SIZE_4_STATE) { // byte 8\n            this._dataLength += (rawByte & 0xFF); // # 2 bytes x 8 bits\n\n            switch (this._frameType) { // If all is correct we should break out of this switch statement\n                case FrameType.SINGLE:\n                case FrameType.CONSECUTIVE:\n                    break;\n                case FrameType.CONTROL:\n                // Ok, well here's some interesting bit of knowledge. Because the start session request is from the phone with no knowledge of version it sends out\n                // a v1 packet. THEREFORE there is no message id field. **** Now you know and knowing is half the battle ****\n                    if (this._version === 1 && this._controlFrameInfo === SdlPacket.FRAME_INFO_START_SERVICE) {\n                        if (this._dataLength === 0) {\n                            return SdlPsm.FINISHED_STATE; // We are done if we don't have any payload\n                        }\n                        if (this._dataLength <= SdlProtocolBase.V1_V2_MTU_SIZE - SdlProtocolBase.V1_HEADER_SIZE) {\n                            this._payload = new Uint8Array(this._dataLength);\n                        } else {\n                            return SdlPsm.ERROR_STATE;\n                        }\n                        this._dumpSize = this._dataLength;\n                        return SdlPsm.DATA_PUMP_STATE;\n                    }\n                    break;\n\n                case FrameType.FIRST:\n                    if (this._dataLength !== SdlPsm.FIRST_FRAME_DATA_SIZE) {\n                        return SdlPsm.ERROR_STATE;\n                    }\n                    break;\n                default:\n                    return SdlPsm.ERROR_STATE;\n            }\n\n            if (this._version === 1) { // Version 1 packets will not have message id's\n                if (this._dataLength === 0) {\n                    return SdlPsm.FINISHED_STATE; // We are done if we don't have any payload\n                }\n                if (this._dataLength <= SdlProtocolBase.V1_V2_MTU_SIZE - SdlProtocolBase.V1_HEADER_SIZE) {\n                    this._payload = new Uint8Array(this._dataLength);\n                } else {\n                    return SdlPsm.ERROR_STATE;\n                }\n                this._dumpSize = this._dataLength;\n                return SdlPsm.DATA_PUMP_STATE;\n            } else {\n                return SdlPsm.MESSAGE_1_STATE;\n            }\n        } else if (state === SdlPsm.MESSAGE_1_STATE) { // byte 9, bytes 9-12 available in version 2+.\n            this._messageID += (rawByte & 0xFF) << 24;\n            return SdlPsm.MESSAGE_2_STATE;\n        } else if (state === SdlPsm.MESSAGE_2_STATE) { // byte 10\n            this._messageID += (rawByte & 0xFF) << 16;\n            return SdlPsm.MESSAGE_3_STATE;\n        } else if (state === SdlPsm.MESSAGE_3_STATE) { // byte 11\n            this._messageID += (rawByte & 0xFF) << 8;\n            return SdlPsm.MESSAGE_4_STATE;\n        } else if (state === SdlPsm.MESSAGE_4_STATE) { // byte 12\n            this._messageID += (rawByte & 0xFF);\n            if (this._dataLength === 0) {\n                return SdlPsm.FINISHED_STATE;\n            }\n            this._dumpSize = this._dataLength;\n            this._payload = new Uint8Array(this._dataLength);\n            return SdlPsm.DATA_PUMP_STATE;\n        } else if (state === SdlPsm.DATA_PUMP_STATE) { // byte 13\n            this._payload[this._dataLength - this._dumpSize] = rawByte;\n            this._dumpSize -= 1;\n            // Do we have any more bytes to read in?\n            if (this._dumpSize > 0) {\n                return SdlPsm.DATA_PUMP_STATE;\n            } else if (this._dumpSize === 0) {\n                return SdlPsm.FINISHED_STATE;\n            } else {\n                return SdlPsm.ERROR_STATE;\n            }\n        }\n    }\n}\n\nSdlPsm.START_STATE                              = 0x0;\nSdlPsm.SERVICE_TYPE_STATE                       = 0x02;\nSdlPsm.CONTROL_FRAME_INFO_STATE                 = 0x03;\nSdlPsm.SESSION_ID_STATE                         = 0x04;\nSdlPsm.DATA_SIZE_1_STATE                        = 0x05;\nSdlPsm.DATA_SIZE_2_STATE                        = 0x06;\nSdlPsm.DATA_SIZE_3_STATE                        = 0x07;\nSdlPsm.DATA_SIZE_4_STATE                        = 0x08;\nSdlPsm.MESSAGE_1_STATE                          = 0x09;\nSdlPsm.MESSAGE_2_STATE                          = 0x0A;\nSdlPsm.MESSAGE_3_STATE                          = 0x0B;\nSdlPsm.MESSAGE_4_STATE                          = 0x0C;\nSdlPsm.DATA_PUMP_STATE                          = 0x0D;\nSdlPsm.FINISHED_STATE                           = 0xFF;\nSdlPsm.ERROR_STATE                              = -1;\n\nSdlPsm.FIRST_FRAME_DATA_SIZE                    = 0x08;\nSdlPsm.VERSION_MASK                             = 0xF0; // 4 highest bits\nSdlPsm.ENCRYPTION_MASK                          = 0x08; // 4th lowest bit\nSdlPsm.FRAME_TYPE_MASK                          = 0x07; // 3 lowest bits\n\nexport { SdlPsm };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SdlPsm } from './SdlPsm.js';\n\nclass TransportBase {\n    /**\n     * @constructor\n     * @param {BaseTransportConfig} transportConfig\n     * @param {TransportCallback} transportCallback\n     */\n    constructor (transportConfig, transportCallback) {\n        this._sdlPsm = new SdlPsm();\n        this._transportConfig = transportConfig;\n        this._transportCallback = transportCallback;\n    }\n\n    start () {\n        throw new Error('start method must be overridden');\n    }\n\n    stop () {\n        throw new Error('stop method must be overridden');\n    }\n\n    /**\n     * @param {SdlPacket} sdlPacket\n     */\n    sendPacket (sdlPacket) {\n        throw new Error('sendPacket method must be overridden');\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        throw new Error('setTransportCallback method must be overridden');\n    }\n}\n\nexport { TransportBase };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportBase } from './TransportBase.js';\nimport { SdlPsm } from './SdlPsm.js';\n\nclass WebSocketClient extends TransportBase {\n    constructor (config, transportCallback) {\n        super(config, transportCallback);\n        this._queue = [];\n        this._isRunning = false;\n        this._wsUrl = `${config.getHost()}:${config.getPort()}`;\n        this._ws = null;\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        this._transportCallback = callback;\n    }\n\n    /**\n     * Opens the transport connection\n     */\n    start () {\n        this._init();\n    }\n\n    /**\n     * Initiates a websocket connection to the url passed in and listens for messages\n     * @private\n     */\n    _init () {\n        this._ws  = new WebSocket(this._wsUrl);\n\n        this._ws.onopen = () => {\n            this._transportCallback.onConnectionEstablished();\n        };\n\n        this._ws.onerror = (error) => {\n            console.error('Failed to connect', error);\n            this._transportCallback.onError();\n        };\n\n        this._ws.onmessage = (msg) => {\n            this._handleIncoming(msg);\n        };\n\n        this._ws.onclose = () => {\n            this._transportCallback.onConnectionTerminated();\n        };\n    }\n\n    /**\n     * Closes the transport connection\n     */\n    stop () {\n        this._ws.close();\n    }\n\n    /**\n     * The contents in the packet should be sent out through the transport\n     * @param {SdlPacket} packet\n     */\n    sendPacket (packet) {\n        const bytes = packet.toPacket();\n        this._ws.send(bytes);\n    }\n\n    /**\n     * This is called whenever a new message comes in\n     * @param {MessageEvent} msg\n     * @private\n     */\n    _handleIncoming (msg) {\n        this._queue.push(msg.data);\n        this._multiByteHandler();\n    }\n\n    /**\n     * Processes received data from the internal queue\n     * @private\n     */\n    _multiByteHandler () {\n        if (this._isRunning) {\n            return;\n        }\n        this._isRunning = true;\n\n        while (this._queue.length > 0) {\n            const msgData = this._queue.shift();\n            new Response(msgData).arrayBuffer().then((arrayBuffer) => {\n                const uint8 = new Uint8Array(arrayBuffer);\n                for (const byte of uint8) {\n                    this._handleByte(byte);\n                }\n            });\n        }\n\n        this._isRunning = false;\n    }\n\n    /**\n     * Feeds a byte through the internal PSM\n     * @param {Number} byte - unsigned 8-bit integer\n     * @private\n     */\n    _handleByte (byte) {\n        const success = this._sdlPsm.handleByte(byte);\n        if (!success) {\n            console.error('failed', this._sdlPsm);\n            this._sdlPsm.reset();\n        }\n        const isFinished = this._sdlPsm.getState() === SdlPsm.FINISHED_STATE;\n\n        if (isFinished) {\n            const packet = this._sdlPsm.getFormedPacket();\n            this._sdlPsm.reset();\n            this._transportCallback.onPacketReceived(packet);\n        }\n    }\n}\n\n\nexport { WebSocketClient };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass TransportCallback {\n    constructor () {\n        this._onConnectionEstablished = null;\n        this._onError = null;\n        this._onConnectionTerminated = null;\n        this._onPacketReceived = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnConnectionEstablished (listener) {\n        this._onConnectionEstablished = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnError (listener) {\n        this._onError = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnConnectionTerminated (listener) {\n        this._onConnectionTerminated = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnPacketReceived (listener) {\n        this._onPacketReceived = listener;\n    }\n\n    /**\n     * Handler for when a connection is successful\n     */\n    onConnectionEstablished () {\n        if (typeof this._onConnectionEstablished === 'function') {\n            this._onConnectionEstablished();\n        }\n    }\n\n    /**\n     * Handler for when a connection is successful\n     */\n    onError () {\n        if (typeof this._onError === 'function') {\n            this._onError();\n        }\n    }\n\n    /**\n     * Handler for when a connection is dropped\n     * @param {String} reason\n     */\n    onConnectionTerminated (reason) {\n        if (typeof this._onConnectionTerminated === 'function') {\n            this._onConnectionTerminated(reason);\n        }\n    }\n\n    /**\n     * Handler for when a packet is received\n     * @param {SdlPacket} packet\n     */\n    onPacketReceived (packet) {\n        if (typeof this._onPacketReceived === 'function') {\n            this._onPacketReceived(packet);\n        }\n    }\n}\n\n\nexport { TransportCallback };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportType } from './enums/TransportType.js';\nimport { WebSocketClient } from './WebSocketClient.js';\nimport { TransportCallback } from './TransportCallback.js';\n\nclass TransportManagerBase {\n    /**\n     * @constructor\n     * @param {BaseTransportConfig} baseTransportConfig\n     * @param {TransportListener} transportListener\n     */\n    constructor (baseTransportConfig, transportListener) {\n        this._transportConfig = baseTransportConfig;\n        this._transportListener = transportListener;\n        this._transport = null;\n        this._isConnected = false;\n        this._transportCallback = new TransportCallback();\n\n        this._transportCallback.setOnConnectionEstablished(() => {\n            this._isConnected = true;\n            transportListener.onTransportConnected();\n        });\n        this._transportCallback.setOnConnectionTerminated(() => {\n            this._isConnected = false;\n        });\n        this._transportCallback.setOnPacketReceived(this.onPacketReceived.bind(this));\n\n        if (this._transportConfig.getTransportType() === TransportType.WEBSOCKET_CLIENT) {\n            this._transport = new WebSocketClient(this._transportConfig, this._transportCallback);\n        } else if (this._transportConfig.getTransportType() === TransportType.CUSTOM) {\n            this._transport = this._transportConfig.getTransport();\n            this._transport.setTransportCallback(this._transportCallback);\n        }\n    }\n\n    onTransportConnected () {\n        this._transportListener.onTransportConnected();\n    }\n\n    /**\n     * @param {Function} func\n     */\n    onTransportDisconnected (func) {\n        this._transportListener.onTransportDisconnected();\n    }\n\n    /**\n     * @param {Function} func\n     */\n    onError (func) {\n        this._transportListener.onError();\n    }\n\n    /**\n     * @param {SdlPacket} sdlPacket\n     */\n    onPacketReceived (sdlPacket) {\n        this._transportListener.onPacketReceived(sdlPacket);\n    }\n\n    /**\n     * Opens the transport connection\n     */\n    start () {\n        if (this._transport !== null && typeof this._transport.start === 'function') {\n            this._transport.start();\n        }\n    }\n\n    /**\n     * Closes the transport connection\n     */\n    stop () {\n        if (this._transport !== null && typeof this._transport.stop === 'function') {\n            this._transport.stop();\n        }\n    }\n\n    /**\n     * The contents in the packet should be sent out through the transport\n     * @param {SdlPacket} packet\n     */\n    sendPacket (packet) {\n        if (this._transport !== null && typeof this._transport.sendPacket === 'function') {\n            this._transport.sendPacket(packet);\n        }\n    }\n\n    /**\n     * @param {TransportType} transportType\n     * @param {String} address\n     */\n    isConnected (transportType, address) {\n        return this._isConnected;\n    }\n}\n\nexport { TransportManagerBase };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nconst { TransportBase } = require('./TransportBase.js');\nconst { SdlPsm } = require('./SdlPsm.js');\nconst WebSocket = require('ws');\n\nclass WebSocketServer extends TransportBase {\n    constructor (transportConfig, transportCallback = null) {\n        super(transportConfig, transportCallback);\n        this._connectionLostInterval = null;\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        this._transportCallback = callback;\n        return this;\n    }\n\n    /**\n     * Start listening for events from the client\n     * @return {WebSocketServer}\n     */\n    start () {\n        const client = this._transportConfig.getClient();\n        const connectionLostTimeout = this._transportConfig.getConnectionLostTimeout();\n\n        // Event listener for an incoming message\n        client.on('message', (message) => {\n            this._handleMessage(message);\n        });\n\n        // Event listener for a closed connection\n        client.on('close', () => {\n            console.log('server received close event');\n            this._stopConnectionLostInterval();\n            if (this._transportCallback !== null) {\n                this._transportCallback.onConnectionTerminated();\n            }\n        });\n\n        // Event listener for errors\n        client.on('error', (errorEvent) => {\n            console.log('server received error event');\n            if (this._transportCallback !== null) {\n                this._transportCallback.onError();\n            }\n        });\n\n        // Pong heartbeat listener\n        client.on('pong', () => {\n            console.log('server received pong event');\n            client.isAlive = true;\n        });\n\n        // Trigger event for connection established\n        if (this._transportCallback !== null) {\n            this._transportCallback.onConnectionEstablished();\n        }\n\n        // Detect broken connections\n        if (connectionLostTimeout > 0) {\n            this._connectionLostInterval = setInterval(() => {\n                if (client.isAlive === false) {\n                    console.log('server deemed client dead');\n                    return client.terminate();\n                }\n\n                // Assume the client is dead and ask it if it's alive\n                client.isAlive = false;\n                console.log('server sending ping to client');\n                client.ping(function () {});\n            }, connectionLostTimeout);\n        }\n\n        client.isAlive = true;\n\n        return this;\n    }\n\n    /**\n     * Stops the WebSocket Server from listening and closes existing connections\n     * @return {WebSocketServer}\n     */\n    stop () {\n        const client = this._transportConfig.getClient();\n\n        client.terminate();\n\n        return this;\n    }\n\n    /**\n     * Sends a packet to the connected WebSocket Server client\n     * @return {WebSocketServer}\n     */\n    sendPacket (sdlPacket) {\n        const client = this._transportConfig.getClient();\n        if (client.readyState === WebSocket.OPEN) {\n            client.send(sdlPacket.toPacket());\n        }\n\n        return this;\n    }\n\n    /**\n     * Stop the connection lost interval if one is defined\n     * @return {WebSocketServer}\n     * @private\n     */\n    _stopConnectionLostInterval () {\n        if (this._connectionLostInterval !== null) {\n            clearInterval(this._connectionLostInterval);\n        }\n\n        return this;\n    }\n\n    /**\n     * This is called whenever a new message comes in\n     * @param {MessageEvent} message\n     * @private\n     */\n    _handleMessage (message) {\n        // Require messages to be binary objects\n        if (typeof message !== 'object' || message.constructor.name !== 'Buffer') {\n            return;\n        }\n\n        // Parse the message\n        let stateProgress = false;\n        for (let messageIndex = 0; messageIndex < message.length; messageIndex++) {\n            stateProgress = this._sdlPsm.handleByte(message[messageIndex]);\n\n            if (!stateProgress) { // We are trying to weed through the bad packet info until we get something\n                this._sdlPsm.reset();\n            } else if (this._sdlPsm.getState() === SdlPsm.FINISHED_STATE) {\n                const packet = this._sdlPsm.getFormedPacket();\n                if (this._transportCallback !== null && packet !== null) {\n                    this._transportCallback.onPacketReceived(packet);\n                }\n\n                this._sdlPsm.reset();\n            }\n        }\n    }\n}\n\nmodule.exports = {\n    WebSocketServer,\n};","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nconst { TransportManagerBase } = require('./TransportManagerBase.js');\nconst { TransportType } = require('./enums/TransportType.js');\nconst { WebSocketServer } = require('./WebSocketServer.js');\n\nclass TransportManager extends TransportManagerBase {\n    constructor (transportConfig, transportListener) {\n        super(transportConfig, transportListener);\n\n        if (this._transportConfig.getTransportType() === TransportType.WEBSOCKET_SERVER) {\n            this._transport = new WebSocketServer(this._transportConfig, this._transportCallback);\n        } else if (this._transport === null) {\n            throw new Error('Unsupported transport type');\n        }\n    }\n}\n\n\nmodule.exports = {\n    TransportManager,\n};","\nimport { SdlProtocolBase } from './SdlProtocolBase.js';\nimport { TransportManager } from './../transport/TransportManager.js';\n\n\nclass SdlProtocol extends SdlProtocolBase {\n    /**\n     * @param {TransportConfigBase} baseTransportConfig\n     * @param {SdlProtocolListener} sdlProtocolListener\n     */\n    constructor (baseTransportConfig, sdlProtocolListener) {\n        super(baseTransportConfig, sdlProtocolListener);\n        this.setTransportManager(new TransportManager(this._transportConfig, this._transportListener));\n    }\n}\n\nexport { SdlProtocol };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { ServiceType } from '../protocol/enums/ServiceType.js';\n\nclass ServiceListenerMap {\n    /**\n    * @constructor\n    */\n    constructor () {\n        this._listeners = {};\n\n        // initialize an array of listeners for each service type\n        this._listeners[ServiceType.CONTROL] = [];\n        this._listeners[ServiceType.RPC] = [];\n        this._listeners[ServiceType.AUDIO] = [];\n        this._listeners[ServiceType.VIDEO] = [];\n        this._listeners[ServiceType.HYBRID] = [];\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} serviceListener\n     */\n    addListener (serviceType, serviceListener) {\n        if (!serviceType) {\n            return;\n        }\n        this._listeners[serviceType].push(serviceListener);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} serviceListener\n     * @return {Boolean} - whether the service got removed\n     */\n    removeListener (serviceType, serviceListener) {\n        if (!serviceType) {\n            return;\n        }\n        const listenerArray = this._listeners[serviceType];\n        let removed = false;\n        // remove matching references to the passed in service listener\n        this._listeners[serviceType] = listenerArray.filter(listener => {\n            removed = true;\n            return listener !== serviceListener;\n        });\n        return removed;\n    }\n\n    /**\n     * Sends this event to all listeners belonging to a specific service type\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {Boolean} isEncrypted\n     */\n    sendEventServiceStarted (session, serviceType, isEncrypted) {\n        const listenerArray = this._listeners[serviceType];\n        for (const index in listenerArray) {\n            listenerArray[index].onServiceStarted(session, serviceType, isEncrypted);\n        }\n    }\n\n    /**\n     * Sends this event to all listeners belonging to a specific service type\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     */\n    sendEventServiceEnded (session, serviceType) {\n        const listenerArray = this._listeners[serviceType];\n        for (const index in listenerArray) {\n            listenerArray[index].onServiceEnded(session, serviceType);\n        }\n    }\n\n    /**\n     * Sends this event to all listeners belonging to a specific service type\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {String} reason\n     */\n    sendEventServiceError (session, serviceType, reason) {\n        const listenerArray = this._listeners[serviceType];\n        for (const index in listenerArray) {\n            listenerArray[index].onServiceError(session, serviceType, reason);\n        }\n    }\n}\n\nexport { ServiceListenerMap };\n","import { VideoStreamingFormat } from '../../rpc/structs/VideoStreamingFormat';\nimport { VideoStreamingCodec } from '../../rpc/enums/VideoStreamingCodec';\nimport { VideoStreamingProtocol } from '../../rpc/enums/VideoStreamingProtocol';\nimport { ImageResolution } from '../../rpc/structs/ImageResolution';\n\n/*\n * Copyright (c) 2019 Livio, Inc.\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided with the\n * distribution.\n *\n * Neither the name of the Livio Inc. nor the names of its contributors\n * may be used to endorse or promote products derived from this software\n * without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n\nconst DEFAULT_PROTOCOL = VideoStreamingProtocol.RAW;\nconst DEFAULT_CODEC = VideoStreamingCodec.H264;\nconst DEFAULT_WIDTH = 1024;\nconst DEFAULT_HEIGHT = 576;\nconst DEFAULT_DENSITY = 240;\nconst DEFAULT_FRAMERATE = 30;\nconst DEFAULT_BITRATE = 512000;\nconst DEFAULT_INTERVAL = 5;\nconst DEFAULT_SCALE = 1.0;\n\nclass VideoStreamingParameters {\n    /**\n     *\n     * @param {number} displayDensity\n     * @param {number} frameRate\n     * @param {number} bitrate\n     * @param {number} interval\n     * @param {ImageResolution} resolution\n     * @param {VideoStreamingFormat} format\n     */\n    constructor (displayDensity = null, frameRate = null, bitrate = null, interval = null, resolution = null, format = null) {\n        this._displayDensity = displayDensity || DEFAULT_DENSITY;\n        this._frameRate = frameRate || DEFAULT_FRAMERATE;\n        this._bitrate = bitrate || DEFAULT_BITRATE;\n        this._interval = interval || DEFAULT_INTERVAL;\n\n        if (!(resolution instanceof ImageResolution)) {\n            resolution = new ImageResolution();\n            resolution.setResolutionWidth(DEFAULT_WIDTH);\n            resolution.setResolutionHeight(DEFAULT_HEIGHT);\n        }\n        this._resolution = resolution;\n\n        if (!(format instanceof VideoStreamingFormat)) {\n            format = new VideoStreamingFormat();\n            format.setProtocol(DEFAULT_PROTOCOL);\n            format.setCodec(DEFAULT_CODEC);\n        }\n\n        this._format = format;\n    }\n\n    /**\n     * Update the values contained in the capability that should have been returned through the SystemCapabilityManager.\n     * This update will use the most preferred streaming format from the module.\n     * @param {VideoStreamingCapability} capability the video streaming capability returned from the SystemCapabilityManager\n     */\n    update (capability) {\n        if (capability.getMaxBitrate() !== null) {\n            this._bitrate = capability.getMaxBitrate() * 1000; // NOTE: the unit of maxBitrate in getSystemCapability is kbps.\n        }\n        let scale = DEFAULT_SCALE;\n        if (capability.getScale() !== null) {\n            scale = capability.getScale();\n        }\n        const resolution = capability.getPreferredResolution();\n        if (resolution !== null) {\n            if (resolution.getResolutionHeight() !== null && resolution.getResolutionHeight() > 0) {\n                this._resolution.setResolutionHeight(Math.floor((resolution.getResolutionHeight() / scale)));\n            }\n            if (resolution.getResolutionWidth() !== null && resolution.getResolutionWidth() > 0) {\n                this._resolution.setResolutionWidth(Math.floor((resolution.getResolutionWidth() / scale)));\n            }\n        }\n        const formats = capability.getSupportedFormats();\n        if (formats !== null && formats.length > 0) {\n            this._format = formats[0];\n        }\n    }\n\n    /**\n     *\n     * @param {number} displayDensity\n     * @return {VideoStreamingParameters}\n     */\n    setDisplayDensity (displayDensity) {\n        this._displayDensity = displayDensity;\n        return this;\n    }\n\n    /**\n     * @return {number}\n     */\n    getDisplayDensity () {\n        return this._displayDensity;\n    }\n\n    /**\n     * @param {number} frameRate\n     * @return {VideoStreamingParameters}\n     */\n    setFrameRate (frameRate) {\n        this._frameRate = frameRate;\n    }\n\n    /**\n     * @return {number}\n     */\n    getFrameRate () {\n        return this._frameRate;\n    }\n\n    /**\n     * @param {number} bitrate\n     * @return {VideoStreamingParameters}\n     */\n    setBitrate (bitrate) {\n        this._bitrate = bitrate;\n        return this;\n    }\n    /**\n     * @return {number}\n     */\n    getBitrate () {\n        return this._bitrate;\n    }\n\n    /**\n     * @param {number} interval\n     * @return {VideoStreamingParameters}\n     */\n    setInterval (interval) {\n        this._interval = interval;\n        return this;\n    }\n\n    /**\n     * @return {number}\n     */\n    getInterval () {\n        return this._interval;\n    }\n\n    /**\n     * @param {VideoStreamingFormat} format\n     * @return {VideoStreamingParameters}\n     */\n    setFormat (format) {\n        this._format = format;\n        return this;\n    }\n\n    /**\n     * @return {VideoStreamingFormat}\n     */\n    getFormat () {\n        return this._format;\n    }\n\n    /**\n     * @param {number} resolution\n     * @return {VideoStreamingParameters}\n     */\n    setResolution (resolution) {\n        this._resolution = resolution;\n        return this;\n    }\n\n    /**\n     * @return {number}\n     */\n    getResolution () {\n        return this._resolution;\n    }\n}\n\nexport { VideoStreamingParameters };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { SdlProtocolListener } from '../protocol/SdlProtocolListener.js';\nimport { SdlProtocol } from '../protocol/SdlProtocol.js';\nimport { ServiceType } from '../protocol/enums/ServiceType.js';\nimport { ServiceListenerMap } from './ServiceListenerMap.js';\nimport { VideoStreamingParameters } from '../streaming/video/VideoStreamingParameters.js';\n\n\n/**\n * @typedef {Object} SdlSession\n * @property {Function} start\n * @property {Function} getSessionId\n * @property {Function} onProtocolSessionStarted\n * @property {Function} onProtocolSessionEnded\n * @property {Function} onProtocolSessionEndedNACKed\n * @property {Function} onRpcMessageReceived\n * @property {Function} sendRpc\n * @property {Function} getMtu\n * @property {Function} close\n * @property {Function} startService\n * @property {Function} endService\n * @property {Function} getCurrentTransportType\n * @property {Function} getIsConnected\n * @property {Function} getProtocolVersion\n * @property {Function} getTransportConfig\n * @property {Function} getSessionHashId\n * @property {Function} addServiceListener\n * @property {Function} removeServiceListener\n * @property {Function} getServiceListeners\n */\nclass SdlSession {\n    /**\n     * @param {TransportConfigBase} baseTransportConfig\n     * @param {SdlSessionListener} sdlSessionListener\n     */\n    constructor (baseTransportConfig, sdlSessionListener) {\n        this._baseTransportConfig = baseTransportConfig;\n        this._sessionId = null;\n        this._sessionHashId = null;\n        this._sdlSessionListener = sdlSessionListener;\n        this._baseTransportConfig = baseTransportConfig;\n\n        // a hash where each key is a service type, and has an array of listeners attached\n        this._serviceListeners = new ServiceListenerMap();\n\n        this._sdlProtocolListener = this._setupSdlProtocolListener();\n\n        this._sdlProtocol = new SdlProtocol(baseTransportConfig, this._sdlProtocolListener);\n    }\n\n    /**\n     * @return {SdlProtocolListener}\n     * @private\n     */\n    _setupSdlProtocolListener () {\n        const sdlProtocolListener = new SdlProtocolListener();\n        sdlProtocolListener.setGetSessionId(this.getSessionId.bind(this));\n        sdlProtocolListener.setOnProtocolSessionStarted(this.onProtocolSessionStarted.bind(this));\n        sdlProtocolListener.setOnProtocolSessionEnded(this.onProtocolSessionEnded.bind(this));\n        sdlProtocolListener.setOnProtocolSessionEndedNACKed(this.onProtocolSessionEndedNACKed.bind(this));\n        sdlProtocolListener.setOnRpcMessageReceived(this.onRpcMessageReceived.bind(this));\n        sdlProtocolListener.setOnTransportConnected(this.onTransportConnected.bind(this));\n\n        sdlProtocolListener.setGetDesiredVideoParams(this.getDesiredVideoParams.bind(this));\n        sdlProtocolListener.setSetAcceptedVideoParams(this.setAcceptedVideoParams.bind(this));\n\n        return sdlProtocolListener;\n    }\n\n    /**\n     * Starts up the SDL protocol class. It will kick off the transport manager and underlying transport.\n     */\n    start () {\n        this._sdlProtocol.start();\n    }\n\n    /** **********************************************************************************************************************************************************************\n     *                                                       BEGIN:    SdlProtocolListener implemented methods\n     ************************************************************************************************************************************************************************/\n\n    /**\n     * @return {Number}  - represents a byte\n     */\n    getSessionId () {\n        return this._sessionId;\n    }\n\n    /**\n     * Event fired when transport (eg tcp, ws, bluetooth) has connected.\n     */\n    onTransportConnected () {\n        this._sdlSessionListener.onTransportConnected();\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {Number} version - represents a byte\n     * @param {String} correlationId\n     * @param {Number} hashId\n     * @param {Boolean} isEncrypted\n     */\n    onProtocolSessionStarted (serviceType, sessionId, version, correlationId, hashId, isEncrypted) {\n        this._sessionId = sessionId;\n\n        if (serviceType === ServiceType.RPC) {\n            this._sessionHashId = hashId;\n        }\n\n        this._sdlSessionListener.onProtocolSessionStarted(serviceType, sessionId, version, correlationId, hashId, isEncrypted);\n        this._serviceListeners.sendEventServiceStarted(this, serviceType, isEncrypted);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {String} correlationId\n     */\n    onProtocolSessionEnded (serviceType, sessionId, correlationId) {\n        this._sdlSessionListener.onProtocolSessionEnded(serviceType, sessionId, correlationId);\n        this._serviceListeners.sendEventServiceEnded(this, serviceType);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {String} correlationId\n     */\n    onProtocolSessionEndedNACKed (serviceType, sessionId, correlationId) {\n        this._sdlSessionListener.onProtocolSessionEndedNACKed(serviceType, sessionId, correlationId);\n        this._serviceListeners.sendEventServiceError(this, serviceType, `End ${serviceType.toString()} Service NACK'ed`);\n    }\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessageReceived (rpcMessage) {\n        this._sdlSessionListener.onRpcMessageReceived(rpcMessage);\n    }\n\n\n    /** **********************************************************************************************************************************************************************\n     *                                                       END:    SdlProtocolListener implemented methods\n     ************************************************************************************************************************************************************************/\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    sendRpc (rpcMessage) {\n        this._sdlProtocol.sendRpc(rpcMessage);\n    }\n\n    /**\n     * Sends an sdlPacket.\n     * @param {SdlPacket} sdlPacket\n     */\n    sendPacket (sdlPacket) {\n        this._sdlProtocol.sendPacket(sdlPacket);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @return {Number} max transport unit for the given service type\n     */\n    getMtu (serviceType) {\n        this._sdlProtocol.getMtu(serviceType);\n    }\n\n    /**\n     * Ends the current session\n     */\n    close () {\n        this._sdlProtocol.endSession(this._sessionId, this._sessionHashId);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     * @param {Boolean} isEncrypted\n     */\n    startService (serviceType, sessionId, isEncrypted) {\n        this._sdlProtocol.startService(serviceType, sessionId, isEncrypted);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionId - represents a byte\n     */\n    endService (serviceType, sessionId) {\n        this._sdlProtocol.endService(serviceType, sessionId);\n    }\n\n    /**\n     * @return {TransportType}\n     */\n    getCurrentTransportType () {\n        return this._baseTransportConfig.getTransportType();\n    }\n\n    /**\n     * @return {Boolean} isConnected\n     */\n    getIsConnected () {\n        return this._sdlProtocol.isConnected();\n    }\n\n    /**\n     * @return {Version}\n     */\n    getProtocolVersion () {\n        return this._sdlProtocol.getProtocolVersion();\n    }\n\n    /**\n     * @return {TransportConfigBase}\n     */\n    getTransportConfig () {\n        return this._baseTransportConfig;\n    }\n\n    /**\n     * @return {Number}\n     */\n    getSessionHashId () {\n        return this._sessionHashId;\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} sdlServiceListener\n     */\n    addServiceListener (serviceType, sdlServiceListener) {\n        this._serviceListeners.addListener(serviceType, sdlServiceListener);\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {SdlServiceListener} sdlServiceListener\n     * @return {Boolean} - whether the removal was successful\n     */\n    removeServiceListener (serviceType, sdlServiceListener) {\n        return this._serviceListeners.removeListener(serviceType, sdlServiceListener);\n    }\n\n    /**\n     * @return {ServiceListenerMap}\n     */\n    getServiceListeners () {\n        return this._serviceListeners;\n    }\n\n    /**\n     *\n     * @param {VideoStreamingParameters} params\n     */\n    setDesiredVideoParams (params) {\n        this._desiredVideoParams = params;\n        return this;\n    }\n\n    /**\n     * Returns the currently set desired video streaming parameters. If there haven't been any set,\n     * the default options will be returned and set for this instance.\n     * @return {VideoStreamingParameters} the desired video streaming parameters\n     */\n    getDesiredVideoParams () {\n        if (!(this._desiredVideoParams instanceof VideoStreamingParameters)) {\n            this._desiredVideoParams = new VideoStreamingParameters();\n        }\n        return this._desiredVideoParams;\n    }\n\n    /**\n     * @param {VideoStreamingParameters} params\n     */\n    setAcceptedVideoParams (params) {\n        this._desiredVideoParams = params;\n        return this;\n    }\n}\n\nexport { SdlSession };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} SdlSessionListener\n */\nclass SdlSessionListener {\n    /**\n\t * @constructor\n\t */\n    constructor () {\n        this._onProtocolSessionStarted = null;\n        this._onProtocolSessionEnded = null;\n        this._onProtocolSessionEndedNACKed = null;\n        this._onRpcMessageReceived = null;\n        this._onTransportConnected = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionStarted (listener) {\n        this._onProtocolSessionStarted = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEnded (listener) {\n        this._onProtocolSessionEnded = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnProtocolSessionEndedNACKed (listener) {\n        this._onProtocolSessionEndedNACKed = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnRpcMessageReceived (listener) {\n        this._onRpcMessageReceived = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnTransportConnected (listener) {\n        this._onTransportConnected = listener;\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID - represents a byte\n     * @param {Number} version - represents a byte\n     * @param {String} correlationID\n     * @param {Number} hashID\n     * @param {Boolean} isEncrypted\n     */\n    onProtocolSessionStarted (serviceType, sessionID, version, correlationID, hashID, isEncrypted) {\n        if (typeof this._onProtocolSessionStarted === 'function') {\n            this._onProtocolSessionStarted(serviceType, sessionID, version, correlationID, hashID, isEncrypted);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID - represents a byte\n     * @param {String} correlationID\n     */\n    onProtocolSessionEnded (serviceType, sessionID, correlationID) {\n        if (typeof this._onProtocolSessionEnded === 'function') {\n            this._onProtocolSessionEnded(serviceType, sessionID, correlationID);\n        }\n    }\n\n    /**\n     * @param {ServiceType} serviceType\n     * @param {Number} sessionID - represents a byte\n     * @param {String} correlationID\n     */\n    onProtocolSessionEndedNACKed (serviceType, sessionID, correlationI) {\n        if (typeof this._onProtocolSessionEndedNACKed === 'function') {\n            this._onProtocolSessionEndedNACKed(serviceType, sessionID, correlationI);\n        }\n    }\n\n    /**\n     * @param {RpcMessage} rpcMessage\n     */\n    onRpcMessageReceived (rpcMessage) {\n        if (typeof this._onRpcMessageReceived === 'function') {\n            this._onRpcMessageReceived(rpcMessage);\n        }\n    }\n\n    /**\n     * Invoked when the app and core connect\n     */\n    onTransportConnected () {\n        if (typeof this._onTransportConnected === 'function') {\n            this._onTransportConnected();\n        }\n    }\n}\n\nexport { SdlSessionListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} ArrayTools\n */\nclass ArrayTools {\n    /**\n     * Removes the item from the array.\n     * This does not mutate the passed in array.\n     * Only the returned array has the value removed.\n     * @param {Array} array\n     * @param {any} value\n     * @return {Array}\n     */\n    static arrayRemove (array, value) {\n        return array.filter(function (ele) {\n            return ele !== value;\n        });\n    }\n}\nexport { ArrayTools };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { RegisterAppInterface } from '../../rpc/messages/RegisterAppInterface.js';\nimport { RpcRequest } from '../../rpc/RpcRequest.js';\nimport { RpcResponse } from '../../rpc/RpcResponse.js';\nimport { RpcListener } from '../../rpc/RpcListener.js';\nimport { SdlSession } from '../../session/SdlSession.js';\nimport { SdlSessionListener } from '../../session/SdlSessionListener.js';\nimport { Version } from '../../util/Version.js';\nimport { ArrayTools } from '../../util/ArrayTools.js';\nimport { SdlMsgVersion } from '../../rpc/structs/SdlMsgVersion.js';\nimport { FunctionID } from '../../rpc/enums/FunctionID.js';\nimport { ServiceType } from '../../protocol/enums/ServiceType.js';\n\n/**\n * NOTE: This could all change and should only be used for testing.\n * This class should also be marked private and behind the SdlManager API\n *\n * usage should be:\n * var lcm = new LifecycleManager(appConfig, lifecycleListener);\n * lcm.setRpcListener( ... );\n * lcm.start();\n * ....\n *\n * lifecycleListener.OnProxyConnected(){\n *  //Possible to start sending RPCs, HMI level should be NONE to start\n *\n * }\n *\n */\nclass LifecycleManager {\n    /**\n    * @param {AppConfig} sdlConfig\n    * @param {LifecycleListener} lifecycleListener\n    * @constructor\n    */\n    constructor (appConfig, lifecycleListener) {\n        if (appConfig === null || lifecycleListener === null\n            || appConfig === undefined || lifecycleListener === undefined\n        ) {\n            throw new Error('Params must not be null');\n        }\n\n        this._appConfig = appConfig;\n        this._lifecycleListener = lifecycleListener;\n        this._sdlSession = new SdlSession(this._appConfig.getTransportConfig(), this._createSessionListener());\n\n        // This is by default until we receive the RAI Response\n        this._rpcSpecVersion = new Version(1, 0, 0);\n\n        this._currentHMIStatus = null;\n        this._firstTimeFull = true;\n        this._responseListeners = new Map();\n        this._maxCorrelationId = 0; // TODO remove when correlation gen is implemented\n        this._rpcListeners = new Map(); // <Number, Array<RpcListener>>\n    }\n\n    /**\n     * @return {SdlSessionListener}\n     */\n    _createSessionListener () {\n        const sessionListener = new SdlSessionListener();\n        sessionListener.setOnProtocolSessionStarted((serviceType, sessionID, version, correlationID, hashID, isEncrypted) => {\n            // Session has been started\n            // TODO check min protocol spec version\n            if (serviceType === ServiceType.RPC) {\n                if (this._appConfig !== null && this._appConfig !== undefined) {\n                    // TODO call prepare on config to make sure it is satisfactory\n                    this.sendRpcMessage(this._createRegisterAppInterface());\n                }\n            }\n        });\n        sessionListener.setOnProtocolSessionEnded((serviceType, sessionID, correlationID) => {\n            // Session has been ended\n        });\n        sessionListener.setOnProtocolSessionEndedNACKed((serviceType, sessionID, correlationID) => {\n            // TODO im not sure why we have this\n        });\n        sessionListener.setOnRpcMessageReceived((rpcMessage) => {\n            // Message has been received\n            this._handleRpc(rpcMessage);\n        });\n        sessionListener.setOnTransportConnected(() => {\n            // transport has been connected\n            this._sdlSession.startService(ServiceType.RPC, 0, false);\n        });\n\n        return sessionListener;\n    }\n\n    /**\n     * @param { RpcMessage } rpcMessage\n     */\n    _handleRpc (rpcMessage) {\n        if (rpcMessage === null || rpcMessage === undefined || rpcMessage.getFunctionName() === null || rpcMessage.getFunctionName() === undefined) {\n            return;\n        }\n\n        const functionID = FunctionID.valueForKey(rpcMessage.getFunctionName()); // this is the number value\n        const listenerArray = this._rpcListeners.get(functionID);\n        if (listenerArray !== null && listenerArray !== undefined) {\n            listenerArray.forEach(function (item) {\n                item.onRpcMessage(rpcMessage);\n            });\n        }\n\n        // Handle individual RPC listeners for request/response pairs\n        if (rpcMessage instanceof RpcResponse) {\n            // null check not needed. its always defined in the constructor\n            if (this._responseListeners.has(rpcMessage.getCorrelationId())) {\n                this._responseListeners.get(rpcMessage.getCorrelationId()).resolve();\n            }\n        }\n    }\n\n    /**\n    * @return {LifecycleManager}\n    */\n    start () {\n        this._setupInternalRpcListeners();\n        this._sdlSession.start();\n        return this;\n    }\n\n    stop () {\n        this._sdlSession.close();\n    }\n\n\n    /**\n     *\n     * @param {FunctionID} functionID\n     * @param {RpcListener} rpcListener\n     */\n    addRpcListener (functionID, rpcListener) {\n        let listenerArray = this._rpcListeners.get(functionID);\n        // If no array exists yet for this function id, create one\n        if (listenerArray === null || listenerArray === undefined) {\n            this._rpcListeners.set(functionID, []);\n            listenerArray = this._rpcListeners.get(functionID);\n        }\n        listenerArray.push(rpcListener);\n    }\n\n    /**\n     *\n     * @param {FunctionID} functionID\n     * @param {RpcListener} rpcListener\n     */\n    removeRpcListener (functionID, rpcListener) {\n        if (rpcListener !== null && rpcListener !== undefined) {\n            const listenerArray = this._rpcListeners.get(functionID);\n            if (listenerArray !== null && listenerArray !== undefined) {\n                this._rpcListeners.set(functionID, ArrayTools.arrayRemove(listenerArray, rpcListener));\n            }\n        }\n    }\n\n    /**\n     *\n     * @param {RpcMessage} rpcMessage\n     */\n    sendRpcMessage (rpcMessage) {\n        if (rpcMessage !== null && rpcMessage !== undefined && this._sdlSession.getIsConnected()) {\n            // TODO we still need to make proper changes to handle specific cases for RPCs ie PLAY_PAUSE / OK\n\n            // TODO create a correlation id generator and handle this in the RPC classes\n            if (rpcMessage instanceof RpcRequest) {\n                if (rpcMessage.getFunctionName !== FunctionID.RegisterAppInterface) { // RAI has a a protected id\n                    rpcMessage.setCorrelationId(++this._maxCorrelationId);\n                }\n\n                // TODO: can't utilize the ability of promises like this\n                if (rpcMessage.getOnRPCResponsePromise() !== null && rpcMessage.getOnRPCResponsePromise() !== undefined) {\n                    // Set the individual response listener for this RPC message\n                    this._responseListeners.set(rpcMessage.getCorrelationId(), rpcMessage.getOnRPCResponsePromise());\n                }\n            }\n            this._sdlSession.sendRpc(rpcMessage);\n        }\n    }\n\n\n\n    /**\n     * @return {RegisterAppInterfaceResponse}\n     */\n    getRegisterAppInterfaceResponse () {\n        return this._registerAppInterfaceResponse;\n    }\n\n\n\n    /**\n    * @return {RegisterAppInterface}\n    */\n    _createRegisterAppInterface () {\n        const registerAppInterface = new RegisterAppInterface();\n        registerAppInterface.setSdlMsgVersion(new SdlMsgVersion().setMajorVersion(LifecycleManager.MAX_RPC_VERSION.getMajor()).setMinorVersion(LifecycleManager.MAX_RPC_VERSION.getMinor()).setPatchVersion(LifecycleManager.MAX_RPC_VERSION.getPatch()))\n            .setAppName(this._appConfig.getAppName())\n            .setFullAppId(this._appConfig.getAppId())\n            .setNgnMediaScreenAppName(this._appConfig.getShortAppName())\n            .setAppHMIType(this._appConfig.getAppTypes())\n            .setLanguageDesired(this._appConfig.getLanguageDesired())\n            .setHmiDisplayLanguageDesired(this._appConfig.getHmiDisplayLanguageDesired())\n            .setIsMediaApplication(this._appConfig.isMediaApp())\n            .setDayColorScheme(this._appConfig.getDayColorScheme())\n            .setNightColorScheme(this._appConfig.getNightColorScheme())\n            .setCorrelationId(LifecycleManager.REGISTER_APP_INTERFACE_CORRELATION_ID);\n\n        // TODO Add all possible items\n\n        return registerAppInterface;\n    }\n\n\n    /* *******************************************************************************************************\n     ********************************** INTERNAL - RPC LISTENERS !! START !! *********************************\n     *********************************************************************************************************/\n\n    _setupInternalRpcListeners () {\n        this._rpcListener = new RpcListener().setOnRpcMessage(rpcMessage => {\n            const functionID = FunctionID.valueForKey(rpcMessage.getFunctionName()); // this is the number value\n\n\n            switch (functionID) {\n                case FunctionID.RegisterAppInterface:\n                    this._processRaiResponse(rpcMessage);\n                    break;\n                case FunctionID.OnHMIStatus: {\n                    // send a single onProxyConnected, when we go from a null HMI level to a defined HMI level\n                    const shouldInit = rpcMessage.getHmiLevel() !== null\n                        && rpcMessage.getHmiLevel() !== undefined\n                        && this._currentHMIStatus === null;\n\n                    this._currentHMIStatus = rpcMessage.getHmiLevel();\n\n                    if (this._lifecycleListener !== null && this._lifecycleListener !== undefined && shouldInit) {\n                        this._lifecycleListener.onProxyConnected(this);\n                    }\n                    break;\n                }\n                default:\n                // RPC not handled yet in LCM\n            }\n        });\n\n        this.addRpcListener(FunctionID.RegisterAppInterface, this._rpcListener);\n        this.addRpcListener(FunctionID.OnHMIStatus, this._rpcListener);\n    }\n\n    /**\n     *\n     * @param {RegisterAppInterfaceResponse} registerAppInterfaceResponse\n     */\n    _processRaiResponse (registerAppInterfaceResponse) {\n        // Cache this RAI Response as it can be used later\n        this._registerAppInterfaceResponse = registerAppInterfaceResponse;\n\n        //  TODO KEY_SDL_MSG_VERSION vs KEY_SYNC_MSG_VERSION sdlVersion: '{GIT_COMMIT}', I think the key name change\n        // is meant to make things clearer about this being an sdl version which is not specific to ford's sync.\n        // There is a key called sdlVersion that is responding with {GIT_COMMIT} that I'm unsure what it is supposed to do.\n        const msgVersion = registerAppInterfaceResponse.getSdlMsgVersion();\n\n        if (msgVersion !== null && msgVersion !== undefined) {\n            this._rpcSpecVersion = new Version(msgVersion.getMajorVersion(), msgVersion.getMajorVersion(), msgVersion.getPatchVersion());\n        } else {\n            this._rpcSpecVersion = LifecycleManager.MAX_RPC_VERSION;\n        }\n\n\n        // TODO check against min RPC spec version config\n\n        // TODO parse RAI for system capabilities\n    }\n}\n\nLifecycleManager.MAX_RPC_VERSION = new Version(6, 0, 0);\nLifecycleManager.REGISTER_APP_INTERFACE_CORRELATION_ID = 65529;\nLifecycleManager.UNREGISTER_APP_INTERFACE_CORRELATION_ID = 65530;\n\n\nexport { LifecycleManager };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} AppServiceType\n * @property {Object} _MAP\n */\nclass AppServiceType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MEDIA () {\n        return AppServiceType._MAP.MEDIA;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get WEATHER () {\n        return AppServiceType._MAP.WEATHER;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get NAVIGATION () {\n        return AppServiceType._MAP.NAVIGATION;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return AppServiceType._valueForKey(key, AppServiceType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return AppServiceType._keyForValue(value, AppServiceType._MAP);\n    }\n}\n\nAppServiceType._MAP = Object.freeze({\n    'MEDIA': 'MEDIA',\n    'WEATHER': 'WEATHER',\n    'NAVIGATION': 'NAVIGATION',\n});\n\nexport { AppServiceType };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of a vehicle maintenance mode.\n * @typedef {Enum} MaintenanceModeStatus\n * @property {Object} _MAP\n */\nclass MaintenanceModeStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MMS_NORMAL () {\n        return MaintenanceModeStatus._MAP.MMS_NORMAL;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MMS_NEAR () {\n        return MaintenanceModeStatus._MAP.MMS_NEAR;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MMS_ACTIVE () {\n        return MaintenanceModeStatus._MAP.MMS_ACTIVE;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get MMS_FEATURE_NOT_PRESENT () {\n        return MaintenanceModeStatus._MAP.MMS_FEATURE_NOT_PRESENT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return MaintenanceModeStatus._valueForKey(key, MaintenanceModeStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return MaintenanceModeStatus._keyForValue(value, MaintenanceModeStatus._MAP);\n    }\n}\n\nMaintenanceModeStatus._MAP = Object.freeze({\n    'MMS_NORMAL': 'NORMAL',\n    'MMS_NEAR': 'NEAR',\n    'MMS_ACTIVE': 'ACTIVE',\n    'MMS_FEATURE_NOT_PRESENT': 'FEATURE_NOT_PRESENT',\n});\n\nexport { MaintenanceModeStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration that describes possible permission states of a policy table entry.\n * @typedef {Enum} PermissionStatus\n * @property {Object} _MAP\n */\nclass PermissionStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PS_ALLOWED () {\n        return PermissionStatus._MAP.PS_ALLOWED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PS_DISALLOWED () {\n        return PermissionStatus._MAP.PS_DISALLOWED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PS_USER_DISALLOWED () {\n        return PermissionStatus._MAP.PS_USER_DISALLOWED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get PS_USER_CONSENT_PENDING () {\n        return PermissionStatus._MAP.PS_USER_CONSENT_PENDING;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PermissionStatus._valueForKey(key, PermissionStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PermissionStatus._keyForValue(value, PermissionStatus._MAP);\n    }\n}\n\nPermissionStatus._MAP = Object.freeze({\n    'PS_ALLOWED': 'ALLOWED',\n    'PS_DISALLOWED': 'DISALLOWED',\n    'PS_USER_DISALLOWED': 'USER_DISALLOWED',\n    'PS_USER_CONSENT_PENDING': 'USER_CONSENT_PENDING',\n});\n\nexport { PermissionStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Predefined screen layout.\n * @typedef {Enum} PredefinedLayout\n * @property {Object} _MAP\n */\nclass PredefinedLayout extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Default media / non-media screen. Can be set as a root screen.\n     * @return {String}\n     */\n    static get DEFAULT () {\n        return PredefinedLayout._MAP.DEFAULT;\n    }\n\n    /**\n     * Default Media screen. Can be set as a root screen.\n     * @return {String}\n     */\n    static get MEDIA () {\n        return PredefinedLayout._MAP.MEDIA;\n    }\n\n    /**\n     * Default Non-media screen. Can be set as a root screen.\n     * @return {String}\n     */\n    static get NON_MEDIA () {\n        return PredefinedLayout._MAP.NON_MEDIA;\n    }\n\n    /**\n     * Custom root media screen containing app-defined onscreen presets. Can be set as a root screen.\n     * @return {String}\n     */\n    static get ONSCREEN_PRESETS () {\n        return PredefinedLayout._MAP.ONSCREEN_PRESETS;\n    }\n\n    /**\n     * Custom root template screen containing full screen map with navigation controls. Can be set as a root screen.\n     * @return {String}\n     */\n    static get NAV_FULLSCREEN_MAP () {\n        return PredefinedLayout._MAP.NAV_FULLSCREEN_MAP;\n    }\n\n    /**\n     * Custom root template screen containing video represented list. Can be set as a root screen.\n     * @return {String}\n     */\n    static get NAV_LIST () {\n        return PredefinedLayout._MAP.NAV_LIST;\n    }\n\n    /**\n     * Custom root template screen containing video represented keyboard. Can be set as a root screen.\n     * @return {String}\n     */\n    static get NAV_KEYBOARD () {\n        return PredefinedLayout._MAP.NAV_KEYBOARD;\n    }\n\n    /**\n     * Custom root template screen containing half-screen graphic with lines of text. Can be set as a root screen.\n     * @return {String}\n     */\n    static get GRAPHIC_WITH_TEXT () {\n        return PredefinedLayout._MAP.GRAPHIC_WITH_TEXT;\n    }\n\n    /**\n     * Custom root template screen containing lines of text with half-screen graphic. Can be set as a root screen.\n     * @return {String}\n     */\n    static get TEXT_WITH_GRAPHIC () {\n        return PredefinedLayout._MAP.TEXT_WITH_GRAPHIC;\n    }\n\n    /**\n     * Custom root template screen containing only tiled SoftButtons. Can be set as a root screen.\n     * @return {String}\n     */\n    static get TILES_ONLY () {\n        return PredefinedLayout._MAP.TILES_ONLY;\n    }\n\n    /**\n     * Custom root template screen containing only text SoftButtons. Can be set as a root screen.\n     * @return {String}\n     */\n    static get TEXTBUTTONS_ONLY () {\n        return PredefinedLayout._MAP.TEXTBUTTONS_ONLY;\n    }\n\n    /**\n     * Custom root template screen containing half-screen graphic with tiled SoftButtons. Can be set as a root screen.\n     * @return {String}\n     */\n    static get GRAPHIC_WITH_TILES () {\n        return PredefinedLayout._MAP.GRAPHIC_WITH_TILES;\n    }\n\n    /**\n     * Custom root template screen containing tiled SoftButtons with half-screen graphic. Can be set as a root screen.\n     * @return {String}\n     */\n    static get TILES_WITH_GRAPHIC () {\n        return PredefinedLayout._MAP.TILES_WITH_GRAPHIC;\n    }\n\n    /**\n     * Custom root template screen containing half-screen graphic with text and SoftButtons. Can be set as a root\n     * screen.\n     * @return {String}\n     */\n    static get GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS () {\n        return PredefinedLayout._MAP.GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS;\n    }\n\n    /**\n     * Custom root template screen containing text and SoftButtons with half-screen graphic. Can be set as a root\n     * screen.\n     * @return {String}\n     */\n    static get TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC () {\n        return PredefinedLayout._MAP.TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC;\n    }\n\n    /**\n     * Custom root template screen containing half-screen graphic with text only SoftButtons. Can be set as a root\n     * screen.\n     * @return {String}\n     */\n    static get GRAPHIC_WITH_TEXTBUTTONS () {\n        return PredefinedLayout._MAP.GRAPHIC_WITH_TEXTBUTTONS;\n    }\n\n    /**\n     * Custom root template screen containing text only SoftButtons with half-screen graphic. Can be set as a root\n     * screen.\n     * @return {String}\n     */\n    static get TEXTBUTTONS_WITH_GRAPHIC () {\n        return PredefinedLayout._MAP.TEXTBUTTONS_WITH_GRAPHIC;\n    }\n\n    /**\n     * Custom root template screen containing a large graphic and SoftButtons. Can be set as a root screen.\n     * @return {String}\n     */\n    static get LARGE_GRAPHIC_WITH_SOFTBUTTONS () {\n        return PredefinedLayout._MAP.LARGE_GRAPHIC_WITH_SOFTBUTTONS;\n    }\n\n    /**\n     * Custom root template screen containing two graphics and SoftButtons. Can be set as a root screen.\n     * @return {String}\n     */\n    static get DOUBLE_GRAPHIC_WITH_SOFTBUTTONS () {\n        return PredefinedLayout._MAP.DOUBLE_GRAPHIC_WITH_SOFTBUTTONS;\n    }\n\n    /**\n     * Custom root template screen containing only a large graphic. Can be set as a root screen.\n     * @return {String}\n     */\n    static get LARGE_GRAPHIC_ONLY () {\n        return PredefinedLayout._MAP.LARGE_GRAPHIC_ONLY;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PredefinedLayout._valueForKey(key, PredefinedLayout._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PredefinedLayout._keyForValue(value, PredefinedLayout._MAP);\n    }\n}\n\nPredefinedLayout._MAP = Object.freeze({\n    'DEFAULT': 'DEFAULT',\n    'MEDIA': 'MEDIA',\n    'NON_MEDIA': 'NON-MEDIA',\n    'ONSCREEN_PRESETS': 'ONSCREEN_PRESETS',\n    'NAV_FULLSCREEN_MAP': 'NAV_FULLSCREEN_MAP',\n    'NAV_LIST': 'NAV_LIST',\n    'NAV_KEYBOARD': 'NAV_KEYBOARD',\n    'GRAPHIC_WITH_TEXT': 'GRAPHIC_WITH_TEXT',\n    'TEXT_WITH_GRAPHIC': 'TEXT_WITH_GRAPHIC',\n    'TILES_ONLY': 'TILES_ONLY',\n    'TEXTBUTTONS_ONLY': 'TEXTBUTTONS_ONLY',\n    'GRAPHIC_WITH_TILES': 'GRAPHIC_WITH_TILES',\n    'TILES_WITH_GRAPHIC': 'TILES_WITH_GRAPHIC',\n    'GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS': 'GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS',\n    'TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC': 'TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC',\n    'GRAPHIC_WITH_TEXTBUTTONS': 'GRAPHIC_WITH_TEXTBUTTONS',\n    'TEXTBUTTONS_WITH_GRAPHIC': 'TEXTBUTTONS_WITH_GRAPHIC',\n    'LARGE_GRAPHIC_WITH_SOFTBUTTONS': 'LARGE_GRAPHIC_WITH_SOFTBUTTONS',\n    'DOUBLE_GRAPHIC_WITH_SOFTBUTTONS': 'DOUBLE_GRAPHIC_WITH_SOFTBUTTONS',\n    'LARGE_GRAPHIC_ONLY': 'LARGE_GRAPHIC_ONLY',\n});\n\nexport { PredefinedLayout };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} PredefinedWindows\n * @property {Object} _MAP\n */\nclass PredefinedWindows extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * The default window is a main window pre-created on behalf of the app.\n     * @return {Number}\n     */\n    static get DEFAULT_WINDOW () {\n        return PredefinedWindows._MAP.DEFAULT_WINDOW;\n    }\n\n    /**\n     * The primary widget of the app.\n     * @return {Number}\n     */\n    static get PRIMARY_WIDGET () {\n        return PredefinedWindows._MAP.PRIMARY_WIDGET;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return PredefinedWindows._valueForKey(key, PredefinedWindows._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return PredefinedWindows._keyForValue(value, PredefinedWindows._MAP);\n    }\n}\n\nPredefinedWindows._MAP = Object.freeze({\n    'DEFAULT_WINDOW': 0,\n    'PRIMARY_WIDGET': 1,\n});\n\nexport { PredefinedWindows };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * @typedef {Enum} TimerMode\n * @property {Object} _MAP\n */\nclass TimerMode extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * Causes the media clock timer to update from 0:00 to a specified time\n     * @return {String}\n     */\n    static get UP () {\n        return TimerMode._MAP.UP;\n    }\n\n    /**\n     * Causes the media clock timer to update from a specified time to 0:00\n     * @return {String}\n     */\n    static get DOWN () {\n        return TimerMode._MAP.DOWN;\n    }\n\n    /**\n     * Indicates to not use the media clock timer\n     * @return {String}\n     */\n    static get NONE () {\n        return TimerMode._MAP.NONE;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return TimerMode._valueForKey(key, TimerMode._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return TimerMode._keyForValue(value, TimerMode._MAP);\n    }\n}\n\nTimerMode._MAP = Object.freeze({\n    'UP': 'UP',\n    'DOWN': 'DOWN',\n    'NONE': 'NONE',\n});\n\nexport { TimerMode };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Reflects the status of given vehicle component.\n * @typedef {Enum} VehicleDataActiveStatus\n * @property {Object} _MAP\n */\nclass VehicleDataActiveStatus extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDAS_INACTIVE_NOT_CONFIRMED () {\n        return VehicleDataActiveStatus._MAP.VDAS_INACTIVE_NOT_CONFIRMED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDAS_INACTIVE_CONFIRMED () {\n        return VehicleDataActiveStatus._MAP.VDAS_INACTIVE_CONFIRMED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDAS_ACTIVE_NOT_CONFIRMED () {\n        return VehicleDataActiveStatus._MAP.VDAS_ACTIVE_NOT_CONFIRMED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDAS_ACTIVE_CONFIRMED () {\n        return VehicleDataActiveStatus._MAP.VDAS_ACTIVE_CONFIRMED;\n    }\n\n    /**\n     * @return {String}\n     */\n    static get VDAS_FAULT () {\n        return VehicleDataActiveStatus._MAP.VDAS_FAULT;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return VehicleDataActiveStatus._valueForKey(key, VehicleDataActiveStatus._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return VehicleDataActiveStatus._keyForValue(value, VehicleDataActiveStatus._MAP);\n    }\n}\n\nVehicleDataActiveStatus._MAP = Object.freeze({\n    'VDAS_INACTIVE_NOT_CONFIRMED': 'INACTIVE_NOT_CONFIRMED',\n    'VDAS_INACTIVE_CONFIRMED': 'INACTIVE_CONFIRMED',\n    'VDAS_ACTIVE_NOT_CONFIRMED': 'ACTIVE_NOT_CONFIRMED',\n    'VDAS_ACTIVE_CONFIRMED': 'ACTIVE_CONFIRMED',\n    'VDAS_FAULT': 'FAULT',\n});\n\nexport { VehicleDataActiveStatus };","/* eslint-disable camelcase */\n/*\n* Copyright (c) 2020, SmartDeviceLink Consortium, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the SmartDeviceLink Consortium Inc. nor the names of\n* its contributors may be used to endorse or promote products derived\n* from this software without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Enum } from '../../util/Enum.js';\n\n/**\n * Enumeration linking message types with function types in WiPro protocol. Assumes enumeration starts at value 0.\n * @typedef {Enum} messageType\n * @property {Object} _MAP\n */\nclass messageType extends Enum {\n    /**\n     * @constructor\n     */\n    constructor () {\n        super();\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get request () {\n        return messageType._MAP.request;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get response () {\n        return messageType._MAP.response;\n    }\n\n    /**\n     * @return {Number}\n     */\n    static get notification () {\n        return messageType._MAP.notification;\n    }\n\n    /**\n     * Get the value for the given enum key\n     * @param key - A key to find in the map of the subclass\n     * @return {*} - Returns a value if found, or null if not found\n     */\n    static valueForKey (key) {\n        return messageType._valueForKey(key, messageType._MAP);\n    }\n\n    /**\n     * Get the key for the given enum value\n     * @param value - A primitive value to find the matching key for in the map of the subclass\n     * @return {*} - Returns a key if found, or null if not found\n     */\n    static keyForValue (value) {\n        return messageType._keyForValue(value, messageType._MAP);\n    }\n}\n\nmessageType._MAP = Object.freeze({\n    'request': 0,\n    'response': 1,\n    'notification': 2,\n});\n\nexport { messageType };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} SdlServiceListener\n */\nclass SdlServiceListener {\n    /**\n\t * @constructor\n\t */\n    constructor () {\n        this._onServiceStarted = null;\n        this._onServiceEnded = null;\n        this._onServiceError = null;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceStarted (listener) {\n        this._onServiceStarted = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceEnded (listener) {\n        this._onServiceEnded = listener;\n    }\n\n    /**\n     * @param {function} listener\n     */\n    setOnServiceError (listener) {\n        this._onServiceError = listener;\n    }\n\n    /**\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {Boolean} isEncrypted\n     */\n    onServiceStarted (session, serviceType, isEncrypted) {\n        if (typeof this._onServiceStarted === 'function') {\n            this._onServiceStarted(session, serviceType, isEncrypted);\n        }\n    }\n\n    /**\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     */\n    onServiceEnded (session, serviceType) {\n        if (typeof this._onServiceEnded === 'function') {\n            this._onServiceEnded(session, serviceType);\n        }\n    }\n\n    /**\n     * @param {SdlSession} session\n     * @param {ServiceType} serviceType\n     * @param {String} reason\n     */\n    onServiceError (session, serviceType, reason) {\n        if (typeof this._onServiceError === 'function') {\n            this._onServiceError(session, serviceType, reason);\n        }\n    }\n}\n\nexport { SdlServiceListener };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportBase } from './TransportBase.js';\nimport { SdlPsm } from './SdlPsm.js';\n\nclass CustomTransport extends TransportBase {\n    constructor (transportConfig, transportCallback = null) {\n        super(transportConfig, transportCallback);\n        this._queue = [];\n        this._isRunning = false;\n    }\n\n    /**\n     * @param {TransportCallback} callback\n     */\n    setTransportCallback (callback) {\n        this._transportCallback = callback;\n        return this;\n    }\n\n    /**\n     * Triggers the transport callback for connection established\n     */\n    start () {\n        if (this._transportCallback !== null) {\n            this._transportCallback.onConnectionEstablished();\n        }\n    }\n\n    /**\n     * Triggers the transport callback for connection terminated\n     */\n    stop () {\n        if (this._transportCallback !== null) {\n            this._transportCallback.onConnectionTerminated('Transport told to stop');\n        }\n    }\n\n    /**\n     * Triggers the transport callback for an error\n     */\n    onError () {\n        if (this._transportCallback !== null) {\n            this._transportCallback.onError();\n        }\n    }\n\n    /**\n     * The contents in the packet should be sent out through the transport\n     * @param {SdlPacket} packet\n     */\n    sendPacket (packet) {\n        const bytes = packet.toPacket();\n        this.onSendPacket(bytes, 0, bytes.length);\n    }\n\n    /**\n     * The app instantiating this class needs to implement this method! sendPacket calls this method\n     * @param {UInt8Array} bytes\n     */\n    onSendPacket (bytes) {\n        throw new Error('onSendPacket method must be overridden');\n    }\n\n    /**\n     * A byte buffer was passed here for processing\n     * @param {Uint8Array} message\n     */\n    onByteBufferReceived (message) {\n        this._queue.push(message);\n        this._multiByteHandler();\n    }\n\n    /**\n     * Processes received data from the internal queue\n     * @private\n     */\n    _multiByteHandler () {\n        if (this._isRunning) {\n            return;\n        }\n        this._isRunning = true;\n\n        while (this._queue.length > 0) {\n            const uint8 = this._queue.shift();\n            for (const byte of uint8) {\n                this._handleByte(byte);\n            }\n        }\n\n        this._isRunning = false;\n    }\n\n    /**\n     * Feeds a byte through the internal PSM\n     * @param {Number} byte - unsigned 8-bit integer\n     * @private\n     */\n    _handleByte (byte) {\n        const sdlPsm = this._sdlPsm;\n\n        const success = sdlPsm.handleByte(byte);\n        if (!success) {\n            console.error('failed', sdlPsm);\n            sdlPsm.reset();\n        }\n        const isFinished = sdlPsm.getState() === SdlPsm.FINISHED_STATE;\n\n        if (isFinished) {\n            const packet = sdlPsm.getFormedPacket();\n            sdlPsm.reset();\n            if (this._transportCallback !== null) {\n                this._transportCallback.onPacketReceived(packet);\n            }\n        }\n    }\n}\n\n\nexport { CustomTransport };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * @typedef {Object} TransportConfigBase\n * @property {TransportType} _transportType\n * @property {Function} getTransportType\n */\nclass TransportConfigBase {\n    /**\n     * @constructor\n     * @param {TransportType} transportType - enum\n     */\n    constructor (transportType) {\n        this._transportType = transportType;\n    }\n\n    /**\n     * @return {TransportType}\n     */\n    getTransportType () {\n        return this._transportType;\n    }\n}\n\nexport { TransportConfigBase };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportConfigBase } from './TransportConfigBase.js';\nimport { TransportType } from './enums/TransportType.js';\n\nclass CustomTransportConfig extends TransportConfigBase {\n    /**\n    * @constructor\n    * @param {CustomTransport} customTransport - An instance of a custom transport\n    */\n    constructor (customTransport) {\n        super(TransportType.CUSTOM);\n        this._customTransport = customTransport;\n    }\n\n    getTransportType () {\n        return TransportType.CUSTOM;\n    }\n\n    getTransport () {\n        return this._customTransport;\n    }\n}\n\nexport { CustomTransportConfig };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass SslConfig {\n    constructor (pemCertificate = null, privateKey = null, password = null) {\n        this._pemCertificate = pemCertificate;\n        this._privateKey = privateKey;\n        this._password = password;\n    }\n\n    /**\n    * Returns the PEM Certificate\n    * @return {string}\n    */\n    getPemCertificate () {\n        return this._pemCertificate;\n    }\n\n    /**\n    * Returns the Private Key\n    * @return {string}\n    */\n    getPrivateKey () {\n        return this._privateKey;\n    }\n\n    /**\n    * Returns the password\n    * @return {string}\n    */\n    getPassword () {\n        return this._password;\n    }\n}\n\nexport { SslConfig };\n","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { TransportType } from './enums/TransportType.js';\nimport { TransportConfigBase } from './TransportConfigBase.js';\n\n\n/**\n * @typedef {Object} TransportConfigBase\n * @property {TransportType} _transportType\n * @property {Function} getTransportType\n */\nclass WebSocketClientConfig extends TransportConfigBase {\n    /**\n     * @constructor\n     * @param {TransportType} transportType - enum\n     */\n    constructor (host, port) {\n        super(TransportType.WEBSOCKET_CLIENT);\n\n        this._host = host;\n        this._port = port;\n    }\n\n    /**\n     * @return String\n     */\n    getHost () {\n        return this._host;\n    }\n\n    /**\n     * @return Number\n     */\n    getPort () {\n        return this._port;\n    }\n}\n\nexport { WebSocketClientConfig };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nclass TransportRecord {\n    /**\n    * @constructor\n    * @param {TransportType} transportType - The type of the transport\n    * @param {String} address\n    */\n    constructor (transportType, address) {\n        this._type = transportType;\n        this._address = address;\n    }\n\n    getType () {\n        return this._type;\n    }\n\n    getAddress () {\n        return this._address;\n    }\n\n    equals (obj) {\n        return (\n            obj instanceof TransportRecord\n            && obj.getType !== null\n            && obj.getType() === this.getType()\n            && obj.getAddress() === this.getAddress()\n        );\n    }\n\n    toString () {\n        return `Transport Type: ${this._type.name()} \\n Address: ${this._address}`;\n    }\n}\n\nexport { TransportRecord };","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nconst { TransportConfigBase } = require('./TransportConfigBase.js');\nconst { TransportType } = require('./enums/TransportType.js');\n\nclass WebSocketServerConfig extends TransportConfigBase {\n    /**\n    * @constructor\n    * @param {WebSocket.client} client - A client connection reference made from a WebSocket server\n    */\n    constructor (client = null, connectionLostTimeout = 60000) {\n        super(TransportType.WEBSOCKET_SERVER);\n        this._client = client;\n        this._connectionLostTimeout = connectionLostTimeout;\n\n        if (client === null) {\n            throw Error('client must be a WebSocket client');\n        }\n    }\n\n    /**\n    * Returns the websocket client\n    * @return {WebSocket.client}\n    */\n    getClient () {\n        return this._client;\n    }\n\n    /**\n    * Returns the websocket connection lost timeout value in milliseconds\n    * @return {Number}\n    */\n    getConnectionLostTimeout () {\n        return this._connectionLostTimeout;\n    }\n}\n\nmodule.exports = {\n    WebSocketServerConfig,\n};","/*\n* Copyright (c) 2019, Livio, Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without\n* modification, are permitted provided that the following conditions are met:\n*\n* Redistributions of source code must retain the above copyright notice, this\n* list of conditions and the following disclaimer.\n*\n* Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following\n* disclaimer in the documentation and/or other materials provided with the\n* distribution.\n*\n* Neither the name of the Livio Inc. nor the names of its contributors\n* may be used to endorse or promote products derived from this software\n* without specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n* POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { AppConfig } from './tmp/manager/AppConfig.js';\nimport { LifecycleListener } from './tmp/manager/lifecycle/LifecycleListener.js';\nimport { LifecycleManager } from './tmp/manager/lifecycle/LifecycleManager.js';\nimport { BinaryFrameHeader } from './tmp/protocol/BinaryFrameHeader.js';\nimport { MessageFrameAssembler } from './tmp/protocol/MessageFrameAssembler.js';\nimport { MessageFrameDisassembler } from './tmp/protocol/MessageFrameDisassembler.js';\nimport { SdlPacket } from './tmp/protocol/SdlPacket.js';\nimport { SdlPacketFactory } from './tmp/protocol/SdlPacketFactory.js';\nimport { SdlProtocol } from './tmp/protocol/SdlProtocol.js';\nimport { SdlProtocolBase } from './tmp/protocol/SdlProtocolBase.js';\nimport { SdlProtocolListener } from './tmp/protocol/SdlProtocolListener.js';\nimport { ControlFrameTags } from './tmp/protocol/enums/ControlFrameTags.js';\nimport { FrameType } from './tmp/protocol/enums/FrameType.js';\nimport { ServiceType } from './tmp/protocol/enums/ServiceType.js';\nimport { RpcCreator } from './tmp/rpc/RpcCreator.js';\nimport { RpcListener } from './tmp/rpc/RpcListener.js';\nimport { RpcMessage } from './tmp/rpc/RpcMessage.js';\nimport { RpcNotification } from './tmp/rpc/RpcNotification.js';\nimport { RpcRequest } from './tmp/rpc/RpcRequest.js';\nimport { RpcResponse } from './tmp/rpc/RpcResponse.js';\nimport { RpcStruct } from './tmp/rpc/RpcStruct.js';\nimport { AmbientLightStatus } from './tmp/rpc/enums/AmbientLightStatus.js';\nimport { AppHMIType } from './tmp/rpc/enums/AppHMIType.js';\nimport { AppInterfaceUnregisteredReason } from './tmp/rpc/enums/AppInterfaceUnregisteredReason.js';\nimport { AppServiceType } from './tmp/rpc/enums/AppServiceType.js';\nimport { AudioStreamingIndicator } from './tmp/rpc/enums/AudioStreamingIndicator.js';\nimport { AudioStreamingState } from './tmp/rpc/enums/AudioStreamingState.js';\nimport { AudioType } from './tmp/rpc/enums/AudioType.js';\nimport { BitsPerSample } from './tmp/rpc/enums/BitsPerSample.js';\nimport { ButtonEventMode } from './tmp/rpc/enums/ButtonEventMode.js';\nimport { ButtonName } from './tmp/rpc/enums/ButtonName.js';\nimport { ButtonPressMode } from './tmp/rpc/enums/ButtonPressMode.js';\nimport { CarModeStatus } from './tmp/rpc/enums/CarModeStatus.js';\nimport { CharacterSet } from './tmp/rpc/enums/CharacterSet.js';\nimport { CompassDirection } from './tmp/rpc/enums/CompassDirection.js';\nimport { ComponentVolumeStatus } from './tmp/rpc/enums/ComponentVolumeStatus.js';\nimport { DefrostZone } from './tmp/rpc/enums/DefrostZone.js';\nimport { DeliveryMode } from './tmp/rpc/enums/DeliveryMode.js';\nimport { DeviceLevelStatus } from './tmp/rpc/enums/DeviceLevelStatus.js';\nimport { Dimension } from './tmp/rpc/enums/Dimension.js';\nimport { Direction } from './tmp/rpc/enums/Direction.js';\nimport { DisplayMode } from './tmp/rpc/enums/DisplayMode.js';\nimport { DisplayType } from './tmp/rpc/enums/DisplayType.js';\nimport { DistanceUnit } from './tmp/rpc/enums/DistanceUnit.js';\nimport { DriverDistractionState } from './tmp/rpc/enums/DriverDistractionState.js';\nimport { ECallConfirmationStatus } from './tmp/rpc/enums/ECallConfirmationStatus.js';\nimport { ElectronicParkBrakeStatus } from './tmp/rpc/enums/ElectronicParkBrakeStatus.js';\nimport { EmergencyEventType } from './tmp/rpc/enums/EmergencyEventType.js';\nimport { FileType } from './tmp/rpc/enums/FileType.js';\nimport { FuelCutoffStatus } from './tmp/rpc/enums/FuelCutoffStatus.js';\nimport { FuelType } from './tmp/rpc/enums/FuelType.js';\nimport { FunctionID } from './tmp/rpc/enums/FunctionID.js';\nimport { GlobalProperty } from './tmp/rpc/enums/GlobalProperty.js';\nimport { HMILevel } from './tmp/rpc/enums/HMILevel.js';\nimport { HmiZoneCapabilities } from './tmp/rpc/enums/HmiZoneCapabilities.js';\nimport { HybridAppPreference } from './tmp/rpc/enums/HybridAppPreference.js';\nimport { IgnitionStableStatus } from './tmp/rpc/enums/IgnitionStableStatus.js';\nimport { IgnitionStatus } from './tmp/rpc/enums/IgnitionStatus.js';\nimport { ImageFieldName } from './tmp/rpc/enums/ImageFieldName.js';\nimport { ImageType } from './tmp/rpc/enums/ImageType.js';\nimport { InteractionMode } from './tmp/rpc/enums/InteractionMode.js';\nimport { KeyboardEvent } from './tmp/rpc/enums/KeyboardEvent.js';\nimport { KeyboardLayout } from './tmp/rpc/enums/KeyboardLayout.js';\nimport { KeypressMode } from './tmp/rpc/enums/KeypressMode.js';\nimport { Language } from './tmp/rpc/enums/Language.js';\nimport { LayoutMode } from './tmp/rpc/enums/LayoutMode.js';\nimport { LightName } from './tmp/rpc/enums/LightName.js';\nimport { LightStatus } from './tmp/rpc/enums/LightStatus.js';\nimport { MaintenanceModeStatus } from './tmp/rpc/enums/MaintenanceModeStatus.js';\nimport { MassageCushion } from './tmp/rpc/enums/MassageCushion.js';\nimport { MassageMode } from './tmp/rpc/enums/MassageMode.js';\nimport { MassageZone } from './tmp/rpc/enums/MassageZone.js';\nimport { MediaClockFormat } from './tmp/rpc/enums/MediaClockFormat.js';\nimport { MediaType } from './tmp/rpc/enums/MediaType.js';\nimport { MenuLayout } from './tmp/rpc/enums/MenuLayout.js';\nimport { MetadataType } from './tmp/rpc/enums/MetadataType.js';\nimport { ModuleType } from './tmp/rpc/enums/ModuleType.js';\nimport { NavigationAction } from './tmp/rpc/enums/NavigationAction.js';\nimport { NavigationJunction } from './tmp/rpc/enums/NavigationJunction.js';\nimport { PRNDL } from './tmp/rpc/enums/PRNDL.js';\nimport { PermissionStatus } from './tmp/rpc/enums/PermissionStatus.js';\nimport { PowerModeQualificationStatus } from './tmp/rpc/enums/PowerModeQualificationStatus.js';\nimport { PowerModeStatus } from './tmp/rpc/enums/PowerModeStatus.js';\nimport { PredefinedLayout } from './tmp/rpc/enums/PredefinedLayout.js';\nimport { PredefinedWindows } from './tmp/rpc/enums/PredefinedWindows.js';\nimport { PrerecordedSpeech } from './tmp/rpc/enums/PrerecordedSpeech.js';\nimport { PrimaryAudioSource } from './tmp/rpc/enums/PrimaryAudioSource.js';\nimport { RadioBand } from './tmp/rpc/enums/RadioBand.js';\nimport { RadioState } from './tmp/rpc/enums/RadioState.js';\nimport { RequestType } from './tmp/rpc/enums/RequestType.js';\nimport { Result } from './tmp/rpc/enums/Result.js';\nimport { RpcType } from './tmp/rpc/enums/RpcType.js';\nimport { SamplingRate } from './tmp/rpc/enums/SamplingRate.js';\nimport { SeatMemoryActionType } from './tmp/rpc/enums/SeatMemoryActionType.js';\nimport { ServiceUpdateReason } from './tmp/rpc/enums/ServiceUpdateReason.js';\nimport { SoftButtonType } from './tmp/rpc/enums/SoftButtonType.js';\nimport { SpeechCapabilities } from './tmp/rpc/enums/SpeechCapabilities.js';\nimport { SupportedSeat } from './tmp/rpc/enums/SupportedSeat.js';\nimport { SystemAction } from './tmp/rpc/enums/SystemAction.js';\nimport { SystemCapabilityType } from './tmp/rpc/enums/SystemCapabilityType.js';\nimport { SystemContext } from './tmp/rpc/enums/SystemContext.js';\nimport { TBTState } from './tmp/rpc/enums/TBTState.js';\nimport { TPMS } from './tmp/rpc/enums/TPMS.js';\nimport { TemperatureUnit } from './tmp/rpc/enums/TemperatureUnit.js';\nimport { TextAlignment } from './tmp/rpc/enums/TextAlignment.js';\nimport { TextFieldName } from './tmp/rpc/enums/TextFieldName.js';\nimport { TimerMode } from './tmp/rpc/enums/TimerMode.js';\nimport { TouchType } from './tmp/rpc/enums/TouchType.js';\nimport { TriggerSource } from './tmp/rpc/enums/TriggerSource.js';\nimport { TurnSignal } from './tmp/rpc/enums/TurnSignal.js';\nimport { UpdateMode } from './tmp/rpc/enums/UpdateMode.js';\nimport { VehicleDataActiveStatus } from './tmp/rpc/enums/VehicleDataActiveStatus.js';\nimport { VehicleDataEventStatus } from './tmp/rpc/enums/VehicleDataEventStatus.js';\nimport { VehicleDataNotificationStatus } from './tmp/rpc/enums/VehicleDataNotificationStatus.js';\nimport { VehicleDataResultCode } from './tmp/rpc/enums/VehicleDataResultCode.js';\nimport { VehicleDataStatus } from './tmp/rpc/enums/VehicleDataStatus.js';\nimport { VehicleDataType } from './tmp/rpc/enums/VehicleDataType.js';\nimport { VentilationMode } from './tmp/rpc/enums/VentilationMode.js';\nimport { VideoStreamingCodec } from './tmp/rpc/enums/VideoStreamingCodec.js';\nimport { VideoStreamingProtocol } from './tmp/rpc/enums/VideoStreamingProtocol.js';\nimport { VideoStreamingState } from './tmp/rpc/enums/VideoStreamingState.js';\nimport { VrCapabilities } from './tmp/rpc/enums/VrCapabilities.js';\nimport { WarningLightStatus } from './tmp/rpc/enums/WarningLightStatus.js';\nimport { WayPointType } from './tmp/rpc/enums/WayPointType.js';\nimport { WindowType } from './tmp/rpc/enums/WindowType.js';\nimport { WiperStatus } from './tmp/rpc/enums/WiperStatus.js';\nimport { messageType } from './tmp/rpc/enums/messageType.js';\nimport { AddCommand } from './tmp/rpc/messages/AddCommand.js';\nimport { AddCommandResponse } from './tmp/rpc/messages/AddCommandResponse.js';\nimport { AddSubMenu } from './tmp/rpc/messages/AddSubMenu.js';\nimport { AddSubMenuResponse } from './tmp/rpc/messages/AddSubMenuResponse.js';\nimport { Alert } from './tmp/rpc/messages/Alert.js';\nimport { AlertManeuver } from './tmp/rpc/messages/AlertManeuver.js';\nimport { AlertManeuverResponse } from './tmp/rpc/messages/AlertManeuverResponse.js';\nimport { AlertResponse } from './tmp/rpc/messages/AlertResponse.js';\nimport { ButtonPress } from './tmp/rpc/messages/ButtonPress.js';\nimport { ButtonPressResponse } from './tmp/rpc/messages/ButtonPressResponse.js';\nimport { CancelInteraction } from './tmp/rpc/messages/CancelInteraction.js';\nimport { CancelInteractionResponse } from './tmp/rpc/messages/CancelInteractionResponse.js';\nimport { ChangeRegistration } from './tmp/rpc/messages/ChangeRegistration.js';\nimport { ChangeRegistrationResponse } from './tmp/rpc/messages/ChangeRegistrationResponse.js';\nimport { CloseApplication } from './tmp/rpc/messages/CloseApplication.js';\nimport { CloseApplicationResponse } from './tmp/rpc/messages/CloseApplicationResponse.js';\nimport { CreateInteractionChoiceSet } from './tmp/rpc/messages/CreateInteractionChoiceSet.js';\nimport { CreateInteractionChoiceSetResponse } from './tmp/rpc/messages/CreateInteractionChoiceSetResponse.js';\nimport { CreateWindow } from './tmp/rpc/messages/CreateWindow.js';\nimport { CreateWindowResponse } from './tmp/rpc/messages/CreateWindowResponse.js';\nimport { DeleteCommand } from './tmp/rpc/messages/DeleteCommand.js';\nimport { DeleteCommandResponse } from './tmp/rpc/messages/DeleteCommandResponse.js';\nimport { DeleteFile } from './tmp/rpc/messages/DeleteFile.js';\nimport { DeleteFileResponse } from './tmp/rpc/messages/DeleteFileResponse.js';\nimport { DeleteInteractionChoiceSet } from './tmp/rpc/messages/DeleteInteractionChoiceSet.js';\nimport { DeleteInteractionChoiceSetResponse } from './tmp/rpc/messages/DeleteInteractionChoiceSetResponse.js';\nimport { DeleteSubMenu } from './tmp/rpc/messages/DeleteSubMenu.js';\nimport { DeleteSubMenuResponse } from './tmp/rpc/messages/DeleteSubMenuResponse.js';\nimport { DeleteWindow } from './tmp/rpc/messages/DeleteWindow.js';\nimport { DeleteWindowResponse } from './tmp/rpc/messages/DeleteWindowResponse.js';\nimport { DiagnosticMessage } from './tmp/rpc/messages/DiagnosticMessage.js';\nimport { DiagnosticMessageResponse } from './tmp/rpc/messages/DiagnosticMessageResponse.js';\nimport { DialNumber } from './tmp/rpc/messages/DialNumber.js';\nimport { DialNumberResponse } from './tmp/rpc/messages/DialNumberResponse.js';\nimport { EncodedSyncPData } from './tmp/rpc/messages/EncodedSyncPData.js';\nimport { EncodedSyncPDataResponse } from './tmp/rpc/messages/EncodedSyncPDataResponse.js';\nimport { EndAudioPassThru } from './tmp/rpc/messages/EndAudioPassThru.js';\nimport { EndAudioPassThruResponse } from './tmp/rpc/messages/EndAudioPassThruResponse.js';\nimport { GenericResponseResponse } from './tmp/rpc/messages/GenericResponseResponse.js';\nimport { GetAppServiceData } from './tmp/rpc/messages/GetAppServiceData.js';\nimport { GetAppServiceDataResponse } from './tmp/rpc/messages/GetAppServiceDataResponse.js';\nimport { GetCloudAppProperties } from './tmp/rpc/messages/GetCloudAppProperties.js';\nimport { GetCloudAppPropertiesResponse } from './tmp/rpc/messages/GetCloudAppPropertiesResponse.js';\nimport { GetDTCs } from './tmp/rpc/messages/GetDTCs.js';\nimport { GetDTCsResponse } from './tmp/rpc/messages/GetDTCsResponse.js';\nimport { GetFile } from './tmp/rpc/messages/GetFile.js';\nimport { GetFileResponse } from './tmp/rpc/messages/GetFileResponse.js';\nimport { GetInteriorVehicleData } from './tmp/rpc/messages/GetInteriorVehicleData.js';\nimport { GetInteriorVehicleDataConsent } from './tmp/rpc/messages/GetInteriorVehicleDataConsent.js';\nimport { GetInteriorVehicleDataConsentResponse } from './tmp/rpc/messages/GetInteriorVehicleDataConsentResponse.js';\nimport { GetInteriorVehicleDataResponse } from './tmp/rpc/messages/GetInteriorVehicleDataResponse.js';\nimport { GetSystemCapability } from './tmp/rpc/messages/GetSystemCapability.js';\nimport { GetSystemCapabilityResponse } from './tmp/rpc/messages/GetSystemCapabilityResponse.js';\nimport { GetVehicleData } from './tmp/rpc/messages/GetVehicleData.js';\nimport { GetVehicleDataResponse } from './tmp/rpc/messages/GetVehicleDataResponse.js';\nimport { GetWayPoints } from './tmp/rpc/messages/GetWayPoints.js';\nimport { GetWayPointsResponse } from './tmp/rpc/messages/GetWayPointsResponse.js';\nimport { ListFiles } from './tmp/rpc/messages/ListFiles.js';\nimport { ListFilesResponse } from './tmp/rpc/messages/ListFilesResponse.js';\nimport { OnAppInterfaceUnregistered } from './tmp/rpc/messages/OnAppInterfaceUnregistered.js';\nimport { OnAppServiceData } from './tmp/rpc/messages/OnAppServiceData.js';\nimport { OnAudioPassThru } from './tmp/rpc/messages/OnAudioPassThru.js';\nimport { OnButtonEvent } from './tmp/rpc/messages/OnButtonEvent.js';\nimport { OnButtonPress } from './tmp/rpc/messages/OnButtonPress.js';\nimport { OnCommand } from './tmp/rpc/messages/OnCommand.js';\nimport { OnDriverDistraction } from './tmp/rpc/messages/OnDriverDistraction.js';\nimport { OnEncodedSyncPData } from './tmp/rpc/messages/OnEncodedSyncPData.js';\nimport { OnHMIStatus } from './tmp/rpc/messages/OnHMIStatus.js';\nimport { OnHashChange } from './tmp/rpc/messages/OnHashChange.js';\nimport { OnInteriorVehicleData } from './tmp/rpc/messages/OnInteriorVehicleData.js';\nimport { OnKeyboardInput } from './tmp/rpc/messages/OnKeyboardInput.js';\nimport { OnLanguageChange } from './tmp/rpc/messages/OnLanguageChange.js';\nimport { OnPermissionsChange } from './tmp/rpc/messages/OnPermissionsChange.js';\nimport { OnRCStatus } from './tmp/rpc/messages/OnRCStatus.js';\nimport { OnSystemCapabilityUpdated } from './tmp/rpc/messages/OnSystemCapabilityUpdated.js';\nimport { OnSystemRequest } from './tmp/rpc/messages/OnSystemRequest.js';\nimport { OnTBTClientState } from './tmp/rpc/messages/OnTBTClientState.js';\nimport { OnTouchEvent } from './tmp/rpc/messages/OnTouchEvent.js';\nimport { OnVehicleData } from './tmp/rpc/messages/OnVehicleData.js';\nimport { OnWayPointChange } from './tmp/rpc/messages/OnWayPointChange.js';\nimport { PerformAppServiceInteraction } from './tmp/rpc/messages/PerformAppServiceInteraction.js';\nimport { PerformAppServiceInteractionResponse } from './tmp/rpc/messages/PerformAppServiceInteractionResponse.js';\nimport { PerformAudioPassThru } from './tmp/rpc/messages/PerformAudioPassThru.js';\nimport { PerformAudioPassThruResponse } from './tmp/rpc/messages/PerformAudioPassThruResponse.js';\nimport { PerformInteraction } from './tmp/rpc/messages/PerformInteraction.js';\nimport { PerformInteractionResponse } from './tmp/rpc/messages/PerformInteractionResponse.js';\nimport { PublishAppService } from './tmp/rpc/messages/PublishAppService.js';\nimport { PublishAppServiceResponse } from './tmp/rpc/messages/PublishAppServiceResponse.js';\nimport { PutFile } from './tmp/rpc/messages/PutFile.js';\nimport { PutFileResponse } from './tmp/rpc/messages/PutFileResponse.js';\nimport { ReadDID } from './tmp/rpc/messages/ReadDID.js';\nimport { ReadDIDResponse } from './tmp/rpc/messages/ReadDIDResponse.js';\nimport { RegisterAppInterface } from './tmp/rpc/messages/RegisterAppInterface.js';\nimport { RegisterAppInterfaceResponse } from './tmp/rpc/messages/RegisterAppInterfaceResponse.js';\nimport { ReleaseInteriorVehicleDataModule } from './tmp/rpc/messages/ReleaseInteriorVehicleDataModule.js';\nimport { ReleaseInteriorVehicleDataModuleResponse } from './tmp/rpc/messages/ReleaseInteriorVehicleDataModuleResponse.js';\nimport { ResetGlobalProperties } from './tmp/rpc/messages/ResetGlobalProperties.js';\nimport { ResetGlobalPropertiesResponse } from './tmp/rpc/messages/ResetGlobalPropertiesResponse.js';\nimport { ScrollableMessage } from './tmp/rpc/messages/ScrollableMessage.js';\nimport { ScrollableMessageResponse } from './tmp/rpc/messages/ScrollableMessageResponse.js';\nimport { SendHapticData } from './tmp/rpc/messages/SendHapticData.js';\nimport { SendHapticDataResponse } from './tmp/rpc/messages/SendHapticDataResponse.js';\nimport { SendLocation } from './tmp/rpc/messages/SendLocation.js';\nimport { SendLocationResponse } from './tmp/rpc/messages/SendLocationResponse.js';\nimport { SetAppIcon } from './tmp/rpc/messages/SetAppIcon.js';\nimport { SetAppIconResponse } from './tmp/rpc/messages/SetAppIconResponse.js';\nimport { SetCloudAppProperties } from './tmp/rpc/messages/SetCloudAppProperties.js';\nimport { SetCloudAppPropertiesResponse } from './tmp/rpc/messages/SetCloudAppPropertiesResponse.js';\nimport { SetDisplayLayout } from './tmp/rpc/messages/SetDisplayLayout.js';\nimport { SetDisplayLayoutResponse } from './tmp/rpc/messages/SetDisplayLayoutResponse.js';\nimport { SetGlobalProperties } from './tmp/rpc/messages/SetGlobalProperties.js';\nimport { SetGlobalPropertiesResponse } from './tmp/rpc/messages/SetGlobalPropertiesResponse.js';\nimport { SetInteriorVehicleData } from './tmp/rpc/messages/SetInteriorVehicleData.js';\nimport { SetInteriorVehicleDataResponse } from './tmp/rpc/messages/SetInteriorVehicleDataResponse.js';\nimport { SetMediaClockTimer } from './tmp/rpc/messages/SetMediaClockTimer.js';\nimport { SetMediaClockTimerResponse } from './tmp/rpc/messages/SetMediaClockTimerResponse.js';\nimport { Show } from './tmp/rpc/messages/Show.js';\nimport { ShowAppMenu } from './tmp/rpc/messages/ShowAppMenu.js';\nimport { ShowAppMenuResponse } from './tmp/rpc/messages/ShowAppMenuResponse.js';\nimport { ShowConstantTBT } from './tmp/rpc/messages/ShowConstantTBT.js';\nimport { ShowConstantTBTResponse } from './tmp/rpc/messages/ShowConstantTBTResponse.js';\nimport { ShowResponse } from './tmp/rpc/messages/ShowResponse.js';\nimport { Slider } from './tmp/rpc/messages/Slider.js';\nimport { SliderResponse } from './tmp/rpc/messages/SliderResponse.js';\nimport { Speak } from './tmp/rpc/messages/Speak.js';\nimport { SpeakResponse } from './tmp/rpc/messages/SpeakResponse.js';\nimport { SubscribeButton } from './tmp/rpc/messages/SubscribeButton.js';\nimport { SubscribeButtonResponse } from './tmp/rpc/messages/SubscribeButtonResponse.js';\nimport { SubscribeVehicleData } from './tmp/rpc/messages/SubscribeVehicleData.js';\nimport { SubscribeVehicleDataResponse } from './tmp/rpc/messages/SubscribeVehicleDataResponse.js';\nimport { SubscribeWayPoints } from './tmp/rpc/messages/SubscribeWayPoints.js';\nimport { SubscribeWayPointsResponse } from './tmp/rpc/messages/SubscribeWayPointsResponse.js';\nimport { SystemRequest } from './tmp/rpc/messages/SystemRequest.js';\nimport { SystemRequestResponse } from './tmp/rpc/messages/SystemRequestResponse.js';\nimport { UnpublishAppService } from './tmp/rpc/messages/UnpublishAppService.js';\nimport { UnpublishAppServiceResponse } from './tmp/rpc/messages/UnpublishAppServiceResponse.js';\nimport { UnregisterAppInterface } from './tmp/rpc/messages/UnregisterAppInterface.js';\nimport { UnregisterAppInterfaceResponse } from './tmp/rpc/messages/UnregisterAppInterfaceResponse.js';\nimport { UnsubscribeButton } from './tmp/rpc/messages/UnsubscribeButton.js';\nimport { UnsubscribeButtonResponse } from './tmp/rpc/messages/UnsubscribeButtonResponse.js';\nimport { UnsubscribeVehicleData } from './tmp/rpc/messages/UnsubscribeVehicleData.js';\nimport { UnsubscribeVehicleDataResponse } from './tmp/rpc/messages/UnsubscribeVehicleDataResponse.js';\nimport { UnsubscribeWayPoints } from './tmp/rpc/messages/UnsubscribeWayPoints.js';\nimport { UnsubscribeWayPointsResponse } from './tmp/rpc/messages/UnsubscribeWayPointsResponse.js';\nimport { UpdateTurnList } from './tmp/rpc/messages/UpdateTurnList.js';\nimport { UpdateTurnListResponse } from './tmp/rpc/messages/UpdateTurnListResponse.js';\nimport { AirbagStatus } from './tmp/rpc/structs/AirbagStatus.js';\nimport { AppInfo } from './tmp/rpc/structs/AppInfo.js';\nimport { AppServiceCapability } from './tmp/rpc/structs/AppServiceCapability.js';\nimport { AppServiceData } from './tmp/rpc/structs/AppServiceData.js';\nimport { AppServiceManifest } from './tmp/rpc/structs/AppServiceManifest.js';\nimport { AppServiceRecord } from './tmp/rpc/structs/AppServiceRecord.js';\nimport { AppServicesCapabilities } from './tmp/rpc/structs/AppServicesCapabilities.js';\nimport { AudioControlCapabilities } from './tmp/rpc/structs/AudioControlCapabilities.js';\nimport { AudioControlData } from './tmp/rpc/structs/AudioControlData.js';\nimport { AudioPassThruCapabilities } from './tmp/rpc/structs/AudioPassThruCapabilities.js';\nimport { BeltStatus } from './tmp/rpc/structs/BeltStatus.js';\nimport { BodyInformation } from './tmp/rpc/structs/BodyInformation.js';\nimport { ButtonCapabilities } from './tmp/rpc/structs/ButtonCapabilities.js';\nimport { Choice } from './tmp/rpc/structs/Choice.js';\nimport { ClimateControlCapabilities } from './tmp/rpc/structs/ClimateControlCapabilities.js';\nimport { ClimateControlData } from './tmp/rpc/structs/ClimateControlData.js';\nimport { CloudAppProperties } from './tmp/rpc/structs/CloudAppProperties.js';\nimport { ClusterModeStatus } from './tmp/rpc/structs/ClusterModeStatus.js';\nimport { Coordinate } from './tmp/rpc/structs/Coordinate.js';\nimport { DIDResult } from './tmp/rpc/structs/DIDResult.js';\nimport { DateTime } from './tmp/rpc/structs/DateTime.js';\nimport { DeviceInfo } from './tmp/rpc/structs/DeviceInfo.js';\nimport { DeviceStatus } from './tmp/rpc/structs/DeviceStatus.js';\nimport { DisplayCapabilities } from './tmp/rpc/structs/DisplayCapabilities.js';\nimport { DisplayCapability } from './tmp/rpc/structs/DisplayCapability.js';\nimport { ECallInfo } from './tmp/rpc/structs/ECallInfo.js';\nimport { EmergencyEvent } from './tmp/rpc/structs/EmergencyEvent.js';\nimport { EqualizerSettings } from './tmp/rpc/structs/EqualizerSettings.js';\nimport { FuelRange } from './tmp/rpc/structs/FuelRange.js';\nimport { GPSData } from './tmp/rpc/structs/GPSData.js';\nimport { Grid } from './tmp/rpc/structs/Grid.js';\nimport { HMICapabilities } from './tmp/rpc/structs/HMICapabilities.js';\nimport { HMIPermissions } from './tmp/rpc/structs/HMIPermissions.js';\nimport { HMISettingsControlCapabilities } from './tmp/rpc/structs/HMISettingsControlCapabilities.js';\nimport { HMISettingsControlData } from './tmp/rpc/structs/HMISettingsControlData.js';\nimport { HapticRect } from './tmp/rpc/structs/HapticRect.js';\nimport { HeadLampStatus } from './tmp/rpc/structs/HeadLampStatus.js';\nimport { Image } from './tmp/rpc/structs/Image.js';\nimport { ImageField } from './tmp/rpc/structs/ImageField.js';\nimport { ImageResolution } from './tmp/rpc/structs/ImageResolution.js';\nimport { KeyboardProperties } from './tmp/rpc/structs/KeyboardProperties.js';\nimport { LightCapabilities } from './tmp/rpc/structs/LightCapabilities.js';\nimport { LightControlCapabilities } from './tmp/rpc/structs/LightControlCapabilities.js';\nimport { LightControlData } from './tmp/rpc/structs/LightControlData.js';\nimport { LightState } from './tmp/rpc/structs/LightState.js';\nimport { LocationDetails } from './tmp/rpc/structs/LocationDetails.js';\nimport { MassageCushionFirmness } from './tmp/rpc/structs/MassageCushionFirmness.js';\nimport { MassageModeData } from './tmp/rpc/structs/MassageModeData.js';\nimport { MediaServiceData } from './tmp/rpc/structs/MediaServiceData.js';\nimport { MediaServiceManifest } from './tmp/rpc/structs/MediaServiceManifest.js';\nimport { MenuParams } from './tmp/rpc/structs/MenuParams.js';\nimport { MetadataTags } from './tmp/rpc/structs/MetadataTags.js';\nimport { ModuleData } from './tmp/rpc/structs/ModuleData.js';\nimport { ModuleInfo } from './tmp/rpc/structs/ModuleInfo.js';\nimport { MyKey } from './tmp/rpc/structs/MyKey.js';\nimport { NavigationCapability } from './tmp/rpc/structs/NavigationCapability.js';\nimport { NavigationInstruction } from './tmp/rpc/structs/NavigationInstruction.js';\nimport { NavigationServiceData } from './tmp/rpc/structs/NavigationServiceData.js';\nimport { NavigationServiceManifest } from './tmp/rpc/structs/NavigationServiceManifest.js';\nimport { OASISAddress } from './tmp/rpc/structs/OASISAddress.js';\nimport { ParameterPermissions } from './tmp/rpc/structs/ParameterPermissions.js';\nimport { PermissionItem } from './tmp/rpc/structs/PermissionItem.js';\nimport { PhoneCapability } from './tmp/rpc/structs/PhoneCapability.js';\nimport { PresetBankCapabilities } from './tmp/rpc/structs/PresetBankCapabilities.js';\nimport { RGBColor } from './tmp/rpc/structs/RGBColor.js';\nimport { RadioControlCapabilities } from './tmp/rpc/structs/RadioControlCapabilities.js';\nimport { RadioControlData } from './tmp/rpc/structs/RadioControlData.js';\nimport { RdsData } from './tmp/rpc/structs/RdsData.js';\nimport { Rectangle } from './tmp/rpc/structs/Rectangle.js';\nimport { RemoteControlCapabilities } from './tmp/rpc/structs/RemoteControlCapabilities.js';\nimport { ScreenParams } from './tmp/rpc/structs/ScreenParams.js';\nimport { SdlMsgVersion } from './tmp/rpc/structs/SdlMsgVersion.js';\nimport { SeatControlCapabilities } from './tmp/rpc/structs/SeatControlCapabilities.js';\nimport { SeatControlData } from './tmp/rpc/structs/SeatControlData.js';\nimport { SeatLocation } from './tmp/rpc/structs/SeatLocation.js';\nimport { SeatLocationCapability } from './tmp/rpc/structs/SeatLocationCapability.js';\nimport { SeatMemoryAction } from './tmp/rpc/structs/SeatMemoryAction.js';\nimport { SingleTireStatus } from './tmp/rpc/structs/SingleTireStatus.js';\nimport { SisData } from './tmp/rpc/structs/SisData.js';\nimport { SoftButton } from './tmp/rpc/structs/SoftButton.js';\nimport { SoftButtonCapabilities } from './tmp/rpc/structs/SoftButtonCapabilities.js';\nimport { StartTime } from './tmp/rpc/structs/StartTime.js';\nimport { StationIDNumber } from './tmp/rpc/structs/StationIDNumber.js';\nimport { SystemCapability } from './tmp/rpc/structs/SystemCapability.js';\nimport { TTSChunk } from './tmp/rpc/structs/TTSChunk.js';\nimport { Temperature } from './tmp/rpc/structs/Temperature.js';\nimport { TemplateColorScheme } from './tmp/rpc/structs/TemplateColorScheme.js';\nimport { TemplateConfiguration } from './tmp/rpc/structs/TemplateConfiguration.js';\nimport { TextField } from './tmp/rpc/structs/TextField.js';\nimport { TireStatus } from './tmp/rpc/structs/TireStatus.js';\nimport { TouchCoord } from './tmp/rpc/structs/TouchCoord.js';\nimport { TouchEvent } from './tmp/rpc/structs/TouchEvent.js';\nimport { TouchEventCapabilities } from './tmp/rpc/structs/TouchEventCapabilities.js';\nimport { Turn } from './tmp/rpc/structs/Turn.js';\nimport { VehicleDataResult } from './tmp/rpc/structs/VehicleDataResult.js';\nimport { VehicleType } from './tmp/rpc/structs/VehicleType.js';\nimport { VideoStreamingCapability } from './tmp/rpc/structs/VideoStreamingCapability.js';\nimport { VideoStreamingFormat } from './tmp/rpc/structs/VideoStreamingFormat.js';\nimport { VrHelpItem } from './tmp/rpc/structs/VrHelpItem.js';\nimport { WeatherAlert } from './tmp/rpc/structs/WeatherAlert.js';\nimport { WeatherData } from './tmp/rpc/structs/WeatherData.js';\nimport { WeatherServiceData } from './tmp/rpc/structs/WeatherServiceData.js';\nimport { WeatherServiceManifest } from './tmp/rpc/structs/WeatherServiceManifest.js';\nimport { WindowCapability } from './tmp/rpc/structs/WindowCapability.js';\nimport { WindowTypeCapabilities } from './tmp/rpc/structs/WindowTypeCapabilities.js';\nimport { SdlServiceListener } from './tmp/session/SdlServiceListener.js';\nimport { SdlSession } from './tmp/session/SdlSession.js';\nimport { SdlSessionListener } from './tmp/session/SdlSessionListener.js';\nimport { ServiceListenerMap } from './tmp/session/ServiceListenerMap.js';\nimport { VideoStreamingParameters } from './tmp/streaming/video/VideoStreamingParameters.js';\nimport { CustomTransport } from './tmp/transport/CustomTransport.js';\nimport { CustomTransportConfig } from './tmp/transport/CustomTransportConfig.js';\nimport { SdlPsm } from './tmp/transport/SdlPsm.js';\nimport { SslConfig } from './tmp/transport/SslConfig.js';\nimport { TransportBase } from './tmp/transport/TransportBase.js';\nimport { TransportCallback } from './tmp/transport/TransportCallback.js';\nimport { TransportConfigBase } from './tmp/transport/TransportConfigBase.js';\nimport { TransportListener } from './tmp/transport/TransportListener.js';\nimport { TransportManager } from './tmp/transport/TransportManager.js';\nimport { TransportManagerBase } from './tmp/transport/TransportManagerBase.js';\nimport { WebSocketClient } from './tmp/transport/WebSocketClient.js';\nimport { WebSocketClientConfig } from './tmp/transport/WebSocketClientConfig.js';\nimport { TransportType } from './tmp/transport/enums/TransportType.js';\nimport { TransportRecord } from './tmp/transport/util/TransportRecord.js';\nimport { ArrayTools } from './tmp/util/ArrayTools.js';\nimport { BitConverter } from './tmp/util/BitConverter.js';\nimport { Bson } from './tmp/util/Bson.js';\nimport { Enum } from './tmp/util/Enum.js';\nimport { JsonRpcMarshaller } from './tmp/util/JsonRpcMarshaller.js';\nimport { TextEncoder } from './tmp/util/TextEncoder.js';\nimport { Version } from './tmp/util/Version.js';\nimport { WebSocketServer } from './tmp/transport/WebSocketServer.js';\nimport { WebSocketServerConfig } from './tmp/transport/WebSocketServerConfig.js';\n\nconst SDL = {\n    manager: {\n        AppConfig,\n        lifecycle: {\n            LifecycleListener,\n            LifecycleManager,\n        },\n    },\n    protocol: {\n        BinaryFrameHeader,\n        MessageFrameAssembler,\n        MessageFrameDisassembler,\n        SdlPacket,\n        SdlPacketFactory,\n        SdlProtocol,\n        SdlProtocolBase,\n        SdlProtocolListener,\n        enums: {\n            ControlFrameTags,\n            FrameType,\n            ServiceType,\n        },\n    },\n    rpc: {\n        RpcCreator,\n        RpcListener,\n        RpcMessage,\n        RpcNotification,\n        RpcRequest,\n        RpcResponse,\n        RpcStruct,\n        enums: {\n            AmbientLightStatus,\n            AppHMIType,\n            AppInterfaceUnregisteredReason,\n            AppServiceType,\n            AudioStreamingIndicator,\n            AudioStreamingState,\n            AudioType,\n            BitsPerSample,\n            ButtonEventMode,\n            ButtonName,\n            ButtonPressMode,\n            CarModeStatus,\n            CharacterSet,\n            CompassDirection,\n            ComponentVolumeStatus,\n            DefrostZone,\n            DeliveryMode,\n            DeviceLevelStatus,\n            Dimension,\n            Direction,\n            DisplayMode,\n            DisplayType,\n            DistanceUnit,\n            DriverDistractionState,\n            ECallConfirmationStatus,\n            ElectronicParkBrakeStatus,\n            EmergencyEventType,\n            FileType,\n            FuelCutoffStatus,\n            FuelType,\n            FunctionID,\n            GlobalProperty,\n            HMILevel,\n            HmiZoneCapabilities,\n            HybridAppPreference,\n            IgnitionStableStatus,\n            IgnitionStatus,\n            ImageFieldName,\n            ImageType,\n            InteractionMode,\n            KeyboardEvent,\n            KeyboardLayout,\n            KeypressMode,\n            Language,\n            LayoutMode,\n            LightName,\n            LightStatus,\n            MaintenanceModeStatus,\n            MassageCushion,\n            MassageMode,\n            MassageZone,\n            MediaClockFormat,\n            MediaType,\n            MenuLayout,\n            MetadataType,\n            ModuleType,\n            NavigationAction,\n            NavigationJunction,\n            PRNDL,\n            PermissionStatus,\n            PowerModeQualificationStatus,\n            PowerModeStatus,\n            PredefinedLayout,\n            PredefinedWindows,\n            PrerecordedSpeech,\n            PrimaryAudioSource,\n            RadioBand,\n            RadioState,\n            RequestType,\n            Result,\n            RpcType,\n            SamplingRate,\n            SeatMemoryActionType,\n            ServiceUpdateReason,\n            SoftButtonType,\n            SpeechCapabilities,\n            SupportedSeat,\n            SystemAction,\n            SystemCapabilityType,\n            SystemContext,\n            TBTState,\n            TPMS,\n            TemperatureUnit,\n            TextAlignment,\n            TextFieldName,\n            TimerMode,\n            TouchType,\n            TriggerSource,\n            TurnSignal,\n            UpdateMode,\n            VehicleDataActiveStatus,\n            VehicleDataEventStatus,\n            VehicleDataNotificationStatus,\n            VehicleDataResultCode,\n            VehicleDataStatus,\n            VehicleDataType,\n            VentilationMode,\n            VideoStreamingCodec,\n            VideoStreamingProtocol,\n            VideoStreamingState,\n            VrCapabilities,\n            WarningLightStatus,\n            WayPointType,\n            WindowType,\n            WiperStatus,\n            messageType,\n        },\n        messages: {\n            AddCommand,\n            AddCommandResponse,\n            AddSubMenu,\n            AddSubMenuResponse,\n            Alert,\n            AlertManeuver,\n            AlertManeuverResponse,\n            AlertResponse,\n            ButtonPress,\n            ButtonPressResponse,\n            CancelInteraction,\n            CancelInteractionResponse,\n            ChangeRegistration,\n            ChangeRegistrationResponse,\n            CloseApplication,\n            CloseApplicationResponse,\n            CreateInteractionChoiceSet,\n            CreateInteractionChoiceSetResponse,\n            CreateWindow,\n            CreateWindowResponse,\n            DeleteCommand,\n            DeleteCommandResponse,\n            DeleteFile,\n            DeleteFileResponse,\n            DeleteInteractionChoiceSet,\n            DeleteInteractionChoiceSetResponse,\n            DeleteSubMenu,\n            DeleteSubMenuResponse,\n            DeleteWindow,\n            DeleteWindowResponse,\n            DiagnosticMessage,\n            DiagnosticMessageResponse,\n            DialNumber,\n            DialNumberResponse,\n            EncodedSyncPData,\n            EncodedSyncPDataResponse,\n            EndAudioPassThru,\n            EndAudioPassThruResponse,\n            GenericResponseResponse,\n            GetAppServiceData,\n            GetAppServiceDataResponse,\n            GetCloudAppProperties,\n            GetCloudAppPropertiesResponse,\n            GetDTCs,\n            GetDTCsResponse,\n            GetFile,\n            GetFileResponse,\n            GetInteriorVehicleData,\n            GetInteriorVehicleDataConsent,\n            GetInteriorVehicleDataConsentResponse,\n            GetInteriorVehicleDataResponse,\n            GetSystemCapability,\n            GetSystemCapabilityResponse,\n            GetVehicleData,\n            GetVehicleDataResponse,\n            GetWayPoints,\n            GetWayPointsResponse,\n            ListFiles,\n            ListFilesResponse,\n            OnAppInterfaceUnregistered,\n            OnAppServiceData,\n            OnAudioPassThru,\n            OnButtonEvent,\n            OnButtonPress,\n            OnCommand,\n            OnDriverDistraction,\n            OnEncodedSyncPData,\n            OnHMIStatus,\n            OnHashChange,\n            OnInteriorVehicleData,\n            OnKeyboardInput,\n            OnLanguageChange,\n            OnPermissionsChange,\n            OnRCStatus,\n            OnSystemCapabilityUpdated,\n            OnSystemRequest,\n            OnTBTClientState,\n            OnTouchEvent,\n            OnVehicleData,\n            OnWayPointChange,\n            PerformAppServiceInteraction,\n            PerformAppServiceInteractionResponse,\n            PerformAudioPassThru,\n            PerformAudioPassThruResponse,\n            PerformInteraction,\n            PerformInteractionResponse,\n            PublishAppService,\n            PublishAppServiceResponse,\n            PutFile,\n            PutFileResponse,\n            ReadDID,\n            ReadDIDResponse,\n            RegisterAppInterface,\n            RegisterAppInterfaceResponse,\n            ReleaseInteriorVehicleDataModule,\n            ReleaseInteriorVehicleDataModuleResponse,\n            ResetGlobalProperties,\n            ResetGlobalPropertiesResponse,\n            ScrollableMessage,\n            ScrollableMessageResponse,\n            SendHapticData,\n            SendHapticDataResponse,\n            SendLocation,\n            SendLocationResponse,\n            SetAppIcon,\n            SetAppIconResponse,\n            SetCloudAppProperties,\n            SetCloudAppPropertiesResponse,\n            SetDisplayLayout,\n            SetDisplayLayoutResponse,\n            SetGlobalProperties,\n            SetGlobalPropertiesResponse,\n            SetInteriorVehicleData,\n            SetInteriorVehicleDataResponse,\n            SetMediaClockTimer,\n            SetMediaClockTimerResponse,\n            Show,\n            ShowAppMenu,\n            ShowAppMenuResponse,\n            ShowConstantTBT,\n            ShowConstantTBTResponse,\n            ShowResponse,\n            Slider,\n            SliderResponse,\n            Speak,\n            SpeakResponse,\n            SubscribeButton,\n            SubscribeButtonResponse,\n            SubscribeVehicleData,\n            SubscribeVehicleDataResponse,\n            SubscribeWayPoints,\n            SubscribeWayPointsResponse,\n            SystemRequest,\n            SystemRequestResponse,\n            UnpublishAppService,\n            UnpublishAppServiceResponse,\n            UnregisterAppInterface,\n            UnregisterAppInterfaceResponse,\n            UnsubscribeButton,\n            UnsubscribeButtonResponse,\n            UnsubscribeVehicleData,\n            UnsubscribeVehicleDataResponse,\n            UnsubscribeWayPoints,\n            UnsubscribeWayPointsResponse,\n            UpdateTurnList,\n            UpdateTurnListResponse,\n        },\n        structs: {\n            AirbagStatus,\n            AppInfo,\n            AppServiceCapability,\n            AppServiceData,\n            AppServiceManifest,\n            AppServiceRecord,\n            AppServicesCapabilities,\n            AudioControlCapabilities,\n            AudioControlData,\n            AudioPassThruCapabilities,\n            BeltStatus,\n            BodyInformation,\n            ButtonCapabilities,\n            Choice,\n            ClimateControlCapabilities,\n            ClimateControlData,\n            CloudAppProperties,\n            ClusterModeStatus,\n            Coordinate,\n            DIDResult,\n            DateTime,\n            DeviceInfo,\n            DeviceStatus,\n            DisplayCapabilities,\n            DisplayCapability,\n            ECallInfo,\n            EmergencyEvent,\n            EqualizerSettings,\n            FuelRange,\n            GPSData,\n            Grid,\n            HMICapabilities,\n            HMIPermissions,\n            HMISettingsControlCapabilities,\n            HMISettingsControlData,\n            HapticRect,\n            HeadLampStatus,\n            Image,\n            ImageField,\n            ImageResolution,\n            KeyboardProperties,\n            LightCapabilities,\n            LightControlCapabilities,\n            LightControlData,\n            LightState,\n            LocationDetails,\n            MassageCushionFirmness,\n            MassageModeData,\n            MediaServiceData,\n            MediaServiceManifest,\n            MenuParams,\n            MetadataTags,\n            ModuleData,\n            ModuleInfo,\n            MyKey,\n            NavigationCapability,\n            NavigationInstruction,\n            NavigationServiceData,\n            NavigationServiceManifest,\n            OASISAddress,\n            ParameterPermissions,\n            PermissionItem,\n            PhoneCapability,\n            PresetBankCapabilities,\n            RGBColor,\n            RadioControlCapabilities,\n            RadioControlData,\n            RdsData,\n            Rectangle,\n            RemoteControlCapabilities,\n            ScreenParams,\n            SdlMsgVersion,\n            SeatControlCapabilities,\n            SeatControlData,\n            SeatLocation,\n            SeatLocationCapability,\n            SeatMemoryAction,\n            SingleTireStatus,\n            SisData,\n            SoftButton,\n            SoftButtonCapabilities,\n            StartTime,\n            StationIDNumber,\n            SystemCapability,\n            TTSChunk,\n            Temperature,\n            TemplateColorScheme,\n            TemplateConfiguration,\n            TextField,\n            TireStatus,\n            TouchCoord,\n            TouchEvent,\n            TouchEventCapabilities,\n            Turn,\n            VehicleDataResult,\n            VehicleType,\n            VideoStreamingCapability,\n            VideoStreamingFormat,\n            VrHelpItem,\n            WeatherAlert,\n            WeatherData,\n            WeatherServiceData,\n            WeatherServiceManifest,\n            WindowCapability,\n            WindowTypeCapabilities,\n        },\n    },\n    session: {\n        SdlServiceListener,\n        SdlSession,\n        SdlSessionListener,\n        ServiceListenerMap,\n    },\n    streaming: {\n        video: {\n            VideoStreamingParameters,\n        },\n    },\n    transport: {\n        CustomTransport,\n        CustomTransportConfig,\n        SdlPsm,\n        SslConfig,\n        TransportBase,\n        TransportCallback,\n        TransportConfigBase,\n        TransportListener,\n        TransportManager,\n        TransportManagerBase,\n        WebSocketClient,\n        WebSocketClientConfig,\n        enums: {\n            TransportType,\n        },\n        util: {\n            TransportRecord,\n        },\n        WebSocketServer,\n        WebSocketServerConfig,\n    },\n    util: {\n        ArrayTools,\n        BitConverter,\n        Bson,\n        Enum,\n        JsonRpcMarshaller,\n        TextEncoder,\n        Version,\n    },\n};\n\nexport default SDL;"],"names":["AppConfig","constructor","_transportConfig","_appId","_appName","_iconName","_iconFile","_shortAppName","_ttsName","_vrSynonyms","_isMediaApp","_languageDesired","_hmiDisplayLanguageDesired","_appTypes","_dayColorScheme","_nightColorScheme","_minimumRPCVersion","_minimumProtocolVersion","setTransportConfig","transportConfig","getTransportConfig","setAppId","appId","getAppId","setAppName","appName","getAppName","setAppIcon","iconName","fileData","getAppIconName","getAppIconFileData","setShortAppName","shortAppName","getShortAppName","setTtsName","ttsName","getTtsName","setVrSynonyms","vrSynonyms","getVrSynonyms","setIsMediaApp","isMediaApp","setLanguageDesired","languageDesired","getLanguageDesired","setHmiDisplayLanguageDesired","hmiDisplayLanguageDesired","getHmiDisplayLanguageDesired","setAppTypes","appTypes","getAppTypes","setDayColorScheme","dayColorScheme","getDayColorScheme","setNightColorScheme","nightColorScheme","getNightColorScheme","setMinimumRPCVersion","minimumRPCVersion","getMinimumRPCVersion","setMinimumProtocolVersion","minimumProtocolVersion","getMinimumProtocolVersion","LifecycleListener","_onProxyConnected","_onProxyClosed","_onServiceStarted","_onServiceEnded","_onError","setOnProxyConnected","listener","setOnProxyClosed","setOnServiceStarted","setOnServiceEnded","setOnError","onProxyConnected","lifecycleManager","onProxyClosed","info","reason","onServiceStarted","serviceType","sessionID","correlationID","_onProtocolSessionEndedNACKed","onServiceEnded","onError","Enum","_keyForValue","value","map","key","keyForValue","Error","_valueForKey","valueForKey","RpcStruct","parameters","_isFormatRequested","_rpcSpecVersion","_parameters","getParameters","getParameter","setParameter","getObject","tClass","_formatObject","obj","undefined","String","Object","prototype","Array","length","outArray","item","push","validateType","isArray","name","AppInfo","setAppDisplayName","KEY_APP_DISPLAY_NAME","getAppDisplayName","setAppBundleID","id","KEY_APP_BUNDLE_ID","getAppBundleID","setAppVersion","version","KEY_APP_VERSION","getAppVersion","icon","KEY_APP_ICON","getAppIcon","RGBColor","setRed","red","KEY_RED","getRed","setGreen","green","KEY_GREEN","getGreen","setBlue","blue","KEY_BLUE","getBlue","TemplateColorScheme","setPrimaryColor","color","KEY_PRIMARY_COLOR","getPrimaryColor","setSecondaryColor","KEY_SECONDARY_COLOR","getSecondaryColor","setBackgroundColor","KEY_BACKGROUND_COLOR","getBackgroundColor","FunctionID","RESERVED","_MAP","RegisterAppInterface","UnregisterAppInterface","SetGlobalProperties","ResetGlobalProperties","AddCommand","DeleteCommand","AddSubMenu","DeleteSubMenu","CreateInteractionChoiceSet","PerformInteraction","DeleteInteractionChoiceSet","Alert","Show","Speak","SetMediaClockTimer","PerformAudioPassThru","EndAudioPassThru","SubscribeButton","UnsubscribeButton","SubscribeVehicleData","UnsubscribeVehicleData","GetVehicleData","ReadDID","GetDTCs","ScrollableMessage","Slider","ShowConstantTBT","AlertManeuver","UpdateTurnList","ChangeRegistration","GenericResponse","PutFile","DeleteFile","ListFiles","SetAppIcon","SetDisplayLayout","DiagnosticMessage","SystemRequest","SendLocation","DialNumber","ButtonPress","GetInteriorVehicleData","SetInteriorVehicleData","GetWayPoints","SubscribeWayPoints","UnsubscribeWayPoints","GetSystemCapability","SendHapticData","SetCloudAppProperties","GetCloudAppProperties","PublishAppService","GetAppServiceData","GetFile","PerformAppServiceInteraction","UnpublishAppService","CancelInteraction","CloseApplication","ShowAppMenu","CreateWindow","DeleteWindow","GetInteriorVehicleDataConsent","ReleaseInteriorVehicleDataModule","OnHMIStatus","OnAppInterfaceUnregistered","OnButtonEvent","OnButtonPress","OnVehicleData","OnCommand","OnTBTClientState","OnDriverDistraction","OnPermissionsChange","OnAudioPassThru","OnLanguageChange","OnKeyboardInput","OnTouchEvent","OnSystemRequest","OnHashChange","OnInteriorVehicleData","OnWayPointChange","OnRCStatus","OnAppServiceData","OnSystemCapabilityUpdated","EncodedSyncPData","SdlPData","OnEncodedSyncPData","OnSyncPData","freeze","SpeechCapabilities","SC_TEXT","SAPI_PHONEMES","LHPLUS_PHONEMES","PRE_RECORDED","SILENCE","FILE","TTSChunk","setText","text","KEY_TEXT","getText","setType","type","KEY_TYPE","getType","SdlMsgVersion","setMajorVersion","KEY_MAJOR_VERSION","getMajorVersion","setMinorVersion","KEY_MINOR_VERSION","getMinorVersion","setPatchVersion","KEY_PATCH_VERSION","getPatchVersion","AppHMIType","DEFAULT","COMMUNICATION","MEDIA","MESSAGING","NAVIGATION","INFORMATION","SOCIAL","BACKGROUND_PROCESS","TESTING","SYSTEM","PROJECTION","REMOTE_CONTROL","Language","EN_US","ES_MX","FR_CA","DE_DE","ES_ES","EN_GB","RU_RU","TR_TR","PL_PL","FR_FR","IT_IT","SV_SE","PT_PT","NL_NL","EN_AU","ZH_CN","ZH_TW","JA_JP","AR_SA","KO_KR","PT_BR","CS_CZ","DA_DK","NO_NO","NL_BE","EL_GR","HU_HU","FI_FI","SK_SK","EN_IN","TH_TH","EN_SA","HE_IL","RO_RO","UK_UA","ID_ID","VI_VN","MS_MY","HI_IN","RpcMessage","store","_isEncrypted","_rpcType","rpcType","_functionName","functionName","_correlationID","setBulkData","bulkData","getRPCType","setRPCType","getFunctionName","setFunctionName","getCorrelationId","setCorrelationId","getBulkData","_bulkData","data","slice","getIsEncrypted","setIsEncrypted","bool","RpcType","NOTIFICATION","RESPONSE","REQUEST","RpcRequest","_promise","getOnRPCResponsePromise","setOnRPCResponsePromise","promise","Promise","DeviceInfo","setHardware","hardware","KEY_HARDWARE","getHardware","setFirmwareRev","rev","KEY_FIRMWARE_REV","getFirmwareRev","setOs","os","KEY_OS","getOs","setOsVersion","KEY_OS_VERSION","getOsVersion","setCarrier","carrier","KEY_CARRIER","getCarrier","setMaxNumberRFCOMMPorts","ports","KEY_MAX_NUMBER_RFCOMM_PORTS","getMaxNumberRFCOMMPorts","setFullAppId","fullAppId","toLowerCase","KEY_FULL_APP_ID","appID","APP_ID_MAX_LENGTH","replace","substring","_setAppId","getFullAppId","KEY_APP_ID","setSdlMsgVersion","KEY_SDL_MSG_VERSION","getSdlMsgVersion","KEY_APP_NAME","KEY_TTS_NAME","setNgnMediaScreenAppName","KEY_NGN_MEDIA_SCREEN_APP_NAME","getNgnMediaScreenAppName","synonyms","KEY_VR_SYNONYMS","setIsMediaApplication","application","KEY_IS_MEDIA_APPLICATION","getIsMediaApplication","desired","KEY_LANGUAGE_DESIRED","KEY_HMI_DISPLAY_LANGUAGE_DESIRED","setAppHMIType","KEY_APP_HMI_TYPE","getAppHMIType","setHashID","KEY_HASH_ID","getHashID","setDeviceInfo","KEY_DEVICE_INFO","getDeviceInfo","setFullAppID","getFullAppID","setAppInfo","KEY_APP_INFO","getAppInfo","scheme","KEY_DAY_COLOR_SCHEME","KEY_NIGHT_COLOR_SCHEME","Result","SUCCESS","UNSUPPORTED_REQUEST","UNSUPPORTED_RESOURCE","DISALLOWED","REJECTED","ABORTED","IGNORED","RETRY","IN_USE","VEHICLE_DATA_NOT_AVAILABLE","TIMED_OUT","INVALID_DATA","CHAR_LIMIT_EXCEEDED","INVALID_ID","DUPLICATE_NAME","APPLICATION_NOT_REGISTERED","WRONG_LANGUAGE","OUT_OF_MEMORY","TOO_MANY_PENDING_REQUESTS","TOO_MANY_APPLICATIONS","APPLICATION_REGISTERED_ALREADY","WARNINGS","GENERIC_ERROR","USER_DISALLOWED","TRUNCATED_DATA","UNSUPPORTED_VERSION","VEHICLE_DATA_NOT_ALLOWED","FILE_NOT_FOUND","CANCEL_ROUTE","SAVED","INVALID_CERT","EXPIRED_CERT","RESUME_FAILED","DATA_NOT_AVAILABLE","READ_ONLY","CORRUPTED_DATA","ENCRYPTION_NEEDED","RpcResponse","getSuccess","KEY_SUCCESS","setSuccess","success","getInfo","KEY_INFO","setInfo","getResultCode","KEY_RESULT_CODE","setResultCode","resultCode","RpcListener","_onRpcMessage","setOnRpcMessage","func","onRpcMessage","rpcMessage","SdlProtocolListener","_onRpcMessageReceived","_onProtocolSessionStarted","_onProtocolSessionEnded","_getSessionId","_onTransportConnected","setOnTransportConnected","setOnRpcMessageReceived","onRpcMessageReceived","setOnProtocolSessionStarted","onTransportConnected","onProtocolSessionStarted","sessionId","correlationId","hashId","isEncrypted","setOnProtocolSessionEnded","onProtocolSessionEnded","setOnProtocolSessionEndedNACKed","onProtocolSessionEndedNACKed","setGetSessionId","getter","getSessionId","setGetDesiredVideoParams","_getDesiredVideoParams","getDesiredVideoParams","setSetAcceptedVideoParams","setter","_setAcceptedVideoParams","setAcceptedVideoParams","params","FrameType","CONTROL","FIRST","CONSECUTIVE","SINGLE","exports","modules","installedModules","__webpack_require__","moduleId","module","i","l","call","m","c","d","o","defineProperty","configurable","enumerable","get","n","__esModule","getDefault","getModuleExports","object","property","hasOwnProperty","p","s","g","Function","eval","e","window","global","base64","ieee754","Buffer","SlowBuffer","INSPECT_MAX_BYTES","TYPED_ARRAY_SUPPORT","typedArraySupport","kMaxLength","arr","Uint8Array","__proto__","foo","subarray","byteLength","createBuffer","that","RangeError","arg","encodingOrOffset","allocUnsafe","from","poolSize","_augment","TypeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","Symbol","species","assertSize","size","alloc","fill","encoding","checked","allocUnsafeSlow","string","isEncoding","actual","write","fromArrayLike","array","byteOffset","isBuffer","len","copy","buffer","isnan","toString","b","_isBuffer","compare","a","x","y","Math","min","concat","list","pos","buf","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","swap16","swap32","swap64","arguments","apply","equals","inspect","str","max","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","bidirectionalIndexOf","val","dir","isNaN","arrayIndexOf","indexOf","lastIndexOf","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","j","includes","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","isFinite","toJSON","_arr","fromByteArray","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","decodeCodePointsArray","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","ret","out","toHex","bytes","newBuf","sliceLen","checkOffset","ext","readUIntLE","noAssert","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","checkInt","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","objectWriteUInt16","littleEndian","writeUInt16LE","writeUInt16BE","objectWriteUInt32","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","checkIEEE754","writeFloat","writeFloatLE","writeFloatBE","writeDouble","writeDoubleLE","writeDoubleBE","targetStart","set","code","charCodeAt","INVALID_BASE64_RE","base64clean","stringtrim","trim","units","Infinity","leadSurrogate","byteArray","hi","lo","toByteArray","src","dst","factory","long","commonjsGlobal","self","createCommonjsModule","fn","getCjsExportFromNamespace","Map","_keys","_values","entry","v","clear","splice","entries","index","next","done","forEach","callback","has","keys","values","map_1","toExtendedJSON","options","relaxed","toNumber","$numberLong","fromExtendedJSON","doc","result","long_1","_classCallCheck","instance","Constructor","_defineProperties","props","descriptor","writable","_createClass","protoProps","staticProps","Double","valueOf","$numberDouble","parseFloat","double_1","_typeof","_typeof2","iterator","_classCallCheck$1","_defineProperties$1","_createClass$1","_possibleConstructorReturn","_assertThisInitialized","ReferenceError","_getPrototypeOf","setPrototypeOf","getPrototypeOf","_inherits","subClass","superClass","create","_setPrototypeOf","Timestamp","_Long","low","high","_this","isLong","$timestamp","t","fromInt","fromNumber","fromBits","lowBits","highBits","opt_radix","timestamp","empty","empty$1","require$$0","normalizedFunctionString","insecureRandomBytes","random","randomBytes","crypto","getRandomValues","utils","setTimeout","clearTimeout","performance","performanceNow","now","mozNow","msNow","oNow","webkitNow","Date","getTime","inherits","ctor","superCtor","super_","TempCtor","inherits$1","_typeof$1","formatRegExp","format","f","isString","objects","args","JSON","stringify","_","isNull","isObject","deprecate","msg","isUndefined","process","warned","deprecated","console","error","debugs","debugEnviron","debuglog","toUpperCase","RegExp","test","pid","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","customInspect","stylizeWithColor","formatValue","styles","styleType","style","arrayToHash","hash","idx","recurseTimes","isFunction","primitive","formatPrimitive","visibleKeys","getOwnPropertyNames","isError","formatError","isRegExp","isDate","base","braces","toUTCString","output","formatArray","formatProperty","pop","reduceToSingleString","simple","isNumber","desc","getOwnPropertyDescriptor","split","line","reduce","prev","cur","ar","isNullOrUndefined","isSymbol","re","objectToString","isPrimitive","maybeBuf","pad","months","timestamp$1","time","getHours","getMinutes","getSeconds","getDate","getMonth","log","origin","add","prop","util","util$1","util$2","_classCallCheck$2","_defineProperties$2","_createClass$2","Buffer$1","randomBytes$1","deprecate$1","PROCESS_UNIQUE","checkForHexRegExp","hasBufferType","err","hexTable","_i","decodeLookup","_Buffer","convertToHex","makeObjectIdError","invalidString","invalidCharacter","ObjectId","generate","cacheHexString","__id","valid","isValid","createFromHexString","toHexString","hexString","_i2","hexChar","otherId","getTimestamp","setTime","$oid","getInc","inc","buffer$$1","createPk","createFromTime","get_inc","custom","objectid","_classCallCheck$3","_defineProperties$3","_createClass$3","alphabetize","sort","BSONRegExp","pattern","$regularExpression","regexp","_classCallCheck$4","_defineProperties$4","_createClass$4","BSONSymbol","$symbol","symbol","_classCallCheck$5","_defineProperties$5","_createClass$5","Int32","$numberInt","int_32","_classCallCheck$6","_defineProperties$6","_createClass$6","Code","scope","$code","$scope","Buffer$2","PARSE_STRING_REGEXP","PARSE_INF_REGEXP","PARSE_NAN_REGEXP","EXPONENT_MAX","EXPONENT_MIN","EXPONENT_BIAS","MAX_DIGITS","NAN_BUFFER","reverse","INF_NEGATIVE_BUFFER","INF_POSITIVE_BUFFER","EXPONENT_REGEX","isDigit","divideu128","DIVISOR","_rem","parts","quotient","rem","shiftLeft","div","modulo","multiply64x2","left","right","leftHigh","shiftRightUnsigned","leftLow","getLowBits","rightHigh","rightLow","productHigh","multiply","productMid","productMid2","productLow","lessThan","uhleft","uhright","ulleft","ulright","invalidErr","message","Decimal128","isNegative","sawRadix","foundNonZero","significantDigits","nDigitsRead","nDigits","radixPosition","firstNonZero","digits","nDigitsStored","digitsInsert","firstDigit","lastDigit","exponent","significandHigh","significandLow","biasedExponent","stringMatch","infMatch","nanMatch","unsignedNumber","expSign","expNumber","digitsString","_digitsString","endOfString","roundDigit","roundBit","dIdx","_dIdx","_dIdx2","significand","dec","and","or","COMBINATION_MASK","EXPONENT_MASK","COMBINATION_INFINITY","COMBINATION_NAN","midh","midl","combination","biased_exponent","significand_digits","scientific_exponent","is_zero","significand_msb","significand128","k","ZERO","least_digits","radix_position","_i3","_i4","$numberDecimal","decimal128","_classCallCheck$7","_defineProperties$7","_createClass$7","MinKey","$minKey","min_key","_classCallCheck$8","_defineProperties$8","_createClass$8","MaxKey","$maxKey","max_key","_classCallCheck$9","_defineProperties$9","_createClass$9","DBRef","collection","oid","db","fields","shift","assign","$ref","$id","$db","db_ref","_classCallCheck$a","_defineProperties$a","_createClass$a","Buffer$3","Binary","subType","sub_type","BSON_BINARY_SUBTYPE_DEFAULT","position","writeStringToArray","BUFFER_SIZE","put","byte_value","decoded_byte","_buffer","isUint8Array","asRaw","newBuffer","convertArraytoUtf8BinaryString","base64String","$binary","startIndex","endIndex","SUBTYPE_DEFAULT","SUBTYPE_FUNCTION","SUBTYPE_BYTE_ARRAY","SUBTYPE_UUID_OLD","SUBTYPE_UUID","SUBTYPE_MD5","SUBTYPE_USER_DEFINED","binary","constants","BSON_INT32_MAX","BSON_INT32_MIN","BSON_INT64_MAX","BSON_INT64_MIN","JS_INT_MAX","JS_INT_MIN","BSON_DATA_NUMBER","BSON_DATA_STRING","BSON_DATA_OBJECT","BSON_DATA_ARRAY","BSON_DATA_BINARY","BSON_DATA_UNDEFINED","BSON_DATA_OID","BSON_DATA_BOOLEAN","BSON_DATA_DATE","BSON_DATA_NULL","BSON_DATA_REGEXP","BSON_DATA_DBPOINTER","BSON_DATA_CODE","BSON_DATA_SYMBOL","BSON_DATA_CODE_W_SCOPE","BSON_DATA_INT","BSON_DATA_TIMESTAMP","BSON_DATA_LONG","BSON_DATA_DECIMAL128","BSON_DATA_MIN_KEY","BSON_DATA_MAX_KEY","BSON_BINARY_SUBTYPE_FUNCTION","BSON_BINARY_SUBTYPE_BYTE_ARRAY","BSON_BINARY_SUBTYPE_UUID","BSON_BINARY_SUBTYPE_MD5","BSON_BINARY_SUBTYPE_USER_DEFINED","_typeof$2","keysToCodecs","deserializeValue","$undefined","filter","startsWith","$date","date","parse","$dbPointer","dollarKeys","strict","replacer","space","serializeArray","serializeDocument","serialize","bson","deserialize","ejson","serializeValue","getISOString","isoStr","toISOString","getUTCMilliseconds","dateNum","inRange","int32Range","int64Range","flags","rx","source","BSON_TYPE_MAPPINGS","subtype","namespace","Long","low_","high_","unsigned","unsigned_","ObjectID","bsontype","_bsontype","_doc","_doc2","mapper","extended_json","FIRST_BIT","FIRST_TWO_BITS","FIRST_THREE_BITS","FIRST_FOUR_BITS","FIRST_FIVE_BITS","TWO_BIT_CHAR","THREE_BIT_CHAR","FOUR_BIT_CHAR","CONTINUING_CHAR","validateUtf8","continuation","byte","validateUtf8_1","validate_utf8","Buffer$4","validateUtf8$1","JS_INT_MAX_LONG","JS_INT_MIN_LONG","functionCache","deserialize$1","allowObjectSmallerThanBufferSize","deserializeObject","evalFunctions","cacheFunctions","cacheFunctionsCrc32","crc32","fieldsAsRaw","raw","bsonRegExp","promoteBuffers","promoteLongs","promoteValues","arrayIndex","elementType","stringSize","_index","objectSize","_index2","_objectSize","arrayOptions","stopIndex","_lowBits","_highBits","long$$1","lessThanOrEqual","greaterThanOrEqual","decimal128$$1","toObject","binarySize","totalBinarySize","regExpOptions","optionsArray","_source","_regExpOptions","_stringSize","_lowBits2","_highBits2","_stringSize2","functionString","isolateEvalWithHash","isolateEval","totalSize","_stringSize3","_functionString","_index3","_objectSize2","scopeObject","_hash","_stringSize4","oidBuffer","_oid","bind","deserializer","readIEEE754","endian","mLen","nBytes","bBE","eLen","eMax","eBias","nBits","NaN","writeIEEE754","rt","abs","LN2","float_parser","_typeof$3","Buffer$5","writeIEEE754$1","normalizedFunctionString$1","regexp$1","ignoreKeys","Set","isDate$1","isRegExp$1","serializeString","numberOfWrittenBytes","serializeNumber","_numberOfWrittenBytes","_numberOfWrittenBytes2","longVal","getHighBits","_numberOfWrittenBytes3","serializeNull","serializeBoolean","serializeDate","dateInMilis","serializeRegExp","ignoreCase","multiline","serializeBSONRegExp","serializeMinMax","serializeObjectId","serializeBuffer","serializeObject","checkKeys","serializeFunctions","ignoreUndefined","path","serializeInto","serializeDecimal128","serializeLong","serializeInt32","serializeDouble","serializeFunction","serializeCode","codeSize","_numberOfWrittenBytes4","serializeBinary","serializeSymbol","serializeDBRef","startingIndex","toBSON","_key","_value","_type","_key2","_value2","_type2","serializer","_typeof$4","Buffer$6","normalizedFunctionString$2","isDate$2","calculateObjectSize","totalLength","calculateElement","ordered_values","calculate_size","Buffer$7","ensure_buffer","ensureBuffer","potentialBuffer","Buffer$8","MAXSIZE","buffer$1","setInternalBufferSize","serialize$1","minInternalBufferSize","serializationIndex","finishedBuffer","serializeWithBufferAndIndex","finalBuffer","deserialize$2","calculateObjectSize$1","deserializeStream","numberOfDocuments","documents","docStartIndex","EJSON","bson_1","bson_2","bson_3","bson_4","bson_5","bson_6","bson_7","bson_8","bson_9","bson_10","bson_11","bson_12","bson_13","bson_14","bson_15","bson_16","bson_17","bson_18","bson_19","bson_20","bson_21","bson_22","bson_23","bson_24","bson_25","bson_26","bson_27","bson_28","bson_29","bson_30","bson_31","bson_32","bson_33","bson_34","bson_35","bson_36","bson_37","bson_38","bson_39","bson_40","bson_41","bson_42","bson_43","bson_44","bson_45","bson_46","bson_47","bson_48","bson_49","bson_50","bson_51","bson_52","bson_53","bson_54","lookup","revLookup","Arr","getLens","b64","validLen","placeHoldersLen","lens","_byteLength","tmp","curByte","tripletToBase64","num","encodeChunk","uint8","extraBytes","maxChunkLength","len2","isLE","wasm","WebAssembly","Instance","Module","__isLong__","INT_CACHE","UINT_CACHE","cachedObj","cache","UZERO","TWO_PWR_64_DBL","MAX_UNSIGNED_VALUE","TWO_PWR_63_DBL","MIN_VALUE","MAX_VALUE","neg","TWO_PWR_32_DBL","pow_dbl","radix","radixToPower","power","fromValue","TWO_PWR_16_DBL","TWO_PWR_24_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","LongPrototype","toInt","isZero","eq","radixLong","rem1","remDiv","intval","getHighBitsUnsigned","getLowBitsUnsigned","getNumBitsAbs","bit","eqz","isPositive","isOdd","isEven","other","notEquals","neq","ne","comp","lt","lte","le","greaterThan","gt","gte","ge","thisNeg","otherNeg","negate","not","addend","a48","a32","a16","a00","b48","b32","b16","b00","c48","c32","c16","c00","subtract","subtrahend","multiplier","get_high","divide","divisor","div_u","div_s","approx","halfThis","shr","shl","toUnsigned","shru","log2","ceil","delta","approxRes","approxRem","rem_u","rem_s","mod","xor","numBits","shiftRight","shr_u","toSigned","toBytes","toBytesLE","toBytesBE","fromBytes","fromBytesLE","fromBytesBE","BSON","Bson","SdlPacket","encryption","frameType","frameInfo","dataSize","messageID","payload","bytesToWrite","_version","_encryption","_frameType","_serviceType","_frameInfo","_sessionID","_dataSize","_messageID","_payload","_offset","_bytesToWrite","_bsonPayload","getVersion","getEncryption","getServiceType","getFrameInfo","getSessionID","getMessageID","getDataSize","setPayload","getPayload","getEncryptionBit","_ENCRYPTION_MASK","getFrameType","_constructPacket","controlFrameInfo","dataView","dataViewIndex","_HEADER_SIZE","_HEADER_SIZE_V1","toPacket","putTag","tag","getTag","_EXTRA_PARCEL_DATA_LENGTH","SERVICE_TYPE_CONTROL","SERVICE_TYPE_RPC","SERVICE_TYPE_PCM","SERVICE_TYPE_VIDEO","SERVICE_TYPE_BULK_DATA","FRAME_INFO_HEART_BEAT","FRAME_INFO_START_SERVICE","FRAME_INFO_START_SERVICE_ACK","FRAME_INFO_START_SERVICE_NAK","FRAME_INFO_END_SERVICE","FRAME_INFO_END_SERVICE_ACK","FRAME_INFO_END_SERVICE_NAK","FRAME_INFO_REGISTER_SECONDARY_TRANSPORT","FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_ACK","FRAME_INFO_REGISTER_SECONDARY_TRANSPORT_NAK","FRAME_INFO_TRANSPORT_EVENT_UPDATE","FRAME_INFO_SERVICE_DATA_ACK","FRAME_INFO_HEART_BEAT_ACK","FRAME_INFO_FINAL_CONNESCUTIVE_FRAME","FRAME_INFO_RESERVED","base64.fromByteArray","ieee754.read","ieee754.write","base64.toByteArray","TextEncoder","encode","Len","resPos","resArr","point","nextcode","JsonRpcMarshaller","marshall","rpcStruct","jsonBytes","paramify","jsonObject","stringVersion","_encode","unmarshall","jsonString","_decode","BinaryFrameHeader","functionId","jsonSize","_functionId","_correlationId","_jsonSize","_jsonData","fromBinaryHeader","binaryFrameHeaderData","binaryFrameHeader","jsonDataStart","HEADER_SIZE","jsonDataEnd","setJsonData","assembleHeaderBytes","setRpcType","getRpcType","setFunctionId","getFunctionId","setJsonSize","getJsonSize","getJsonData","MessageFrameDisassembler","rpcRequest","messageId","mtu","packetCallback","_rpcRequest","_sessionId","_messageId","_mtu","_packetCallback","buildRPC","cb","_doRequest","_buildRPCMainBuffer","rpcBulkData","jsonBuffer","bfh","headerSize","bulkDataSize","totalMessageSize","mainBuffer","frameCount","fullPacket","view","DataView","setUint32","firstHeader","_buildConsecutiveFrames","sdlPacket","frameSequenceNumber","count","header","TransportListener","_onTransportDisconnected","_onPacketReceived","setOnTransportDisconnected","setOnPacketReceived","onTransportDisconnected","onPacketReceived","Version","major","minor","patch","setMajor","setMinor","setPatch","_major","getMajor","_minor","getMinor","_patch","getPatch","versions","isNewerThan","ServiceType","RPC","AUDIO","VIDEO","HYBRID","MessageFrameAssembler","_callback","_accumulator","_totalConsecutiveFrames","_consecutiveFramesHandledCount","_consecutiveFramesDataLength","handleFrame","_handleMultiFrameMessage","_handleFirstDataFrame","dataLength","_handleConsecutiveFrame","frameSequence","warn","finishedSdlPacket","ControlFrameTags","StartServiceACKBase","MTU","NAKBase","REJECTED_PARAMS","StartServiceProtocolVersion","PROTOCOL_VERSION","StartServiceHashId","HASH_ID","StartServiceDimensions","HEIGHT","WIDTH","StartService","StartServiceACK","SECONDARY_TRANSPORTS","AUDIO_SERVICE_TRANSPORTS","VIDEO_SERVICE_TRANSPORTS","AUTH_TOKEN","StartServiceNAK","EndService","EndServiceACK","EndServiceNAK","TransportEventUpdate","TCP_IP_ADDRESS","TCP_PORT","RegisterSecondaryTransport","RegisterSecondaryTransportACK","RegisterSecondaryTransportNAK","REASON","Audio","Video","VIDEO_PROTOCOL","VIDEO_CODEC","BitConverter","arrayBufferToInt32","getUint32","int32ToArrayBuffer","SdlPacketFactory","createHeartbeatACK","createEndSession","hashID","endSession","SoftButtonCapabilities","setShortPressAvailable","available","KEY_SHORT_PRESS_AVAILABLE","getShortPressAvailable","setLongPressAvailable","KEY_LONG_PRESS_AVAILABLE","getLongPressAvailable","setUpDownAvailable","KEY_UP_DOWN_AVAILABLE","getUpDownAvailable","setImageSupported","supported","KEY_IMAGE_SUPPORTED","getImageSupported","setTextSupported","KEY_TEXT_SUPPORTED","getTextSupported","PrerecordedSpeech","HELP_JINGLE","INITIAL_JINGLE","LISTEN_JINGLE","POSITIVE_JINGLE","NEGATIVE_JINGLE","PresetBankCapabilities","setOnScreenPresetsAvailable","KEY_ON_SCREEN_PRESETS_AVAILABLE","getOnScreenPresetsAvailable","VehicleType","setMake","make","KEY_MAKE","getMake","setModel","model","KEY_MODEL","getModel","setModelYear","year","KEY_MODEL_YEAR","getModelYear","setTrim","KEY_TRIM","getTrim","HmiZoneCapabilities","FRONT","BACK","MediaClockFormat","CLOCK1","CLOCK2","CLOCK3","CLOCKTEXT1","CLOCKTEXT2","CLOCKTEXT3","CLOCKTEXT4","ImageResolution","setResolutionWidth","width","KEY_RESOLUTION_WIDTH","getResolutionWidth","setResolutionHeight","height","KEY_RESOLUTION_HEIGHT","getResolutionHeight","TouchEventCapabilities","setPressAvailable","KEY_PRESS_AVAILABLE","getPressAvailable","setMultiTouchAvailable","KEY_MULTI_TOUCH_AVAILABLE","getMultiTouchAvailable","setDoublePressAvailable","KEY_DOUBLE_PRESS_AVAILABLE","getDoublePressAvailable","ScreenParams","setResolution","resolution","KEY_RESOLUTION","getResolution","setTouchEventAvailable","KEY_TOUCH_EVENT_AVAILABLE","getTouchEventAvailable","ImageFieldName","softButtonImage","choiceImage","choiceSecondaryImage","vrHelpItem","turnIcon","menuIcon","cmdIcon","appIcon","graphic","secondaryGraphic","showConstantTBTIcon","showConstantTBTNextTurnIcon","locationImage","alertIcon","FileType","GRAPHIC_BMP","GRAPHIC_JPEG","GRAPHIC_PNG","AUDIO_WAVE","AUDIO_MP3","AUDIO_AAC","BINARY","ImageField","setName","KEY_NAME","getName","setImageTypeSupported","KEY_IMAGE_TYPE_SUPPORTED","getImageTypeSupported","setImageResolution","KEY_IMAGE_RESOLUTION","getImageResolution","DisplayType","CID","TYPE2","TYPE5","NGN","GEN2_8_DMA","GEN2_6_DMA","MFD3","MFD4","MFD5","GEN3_8_INCH","SDL_GENERIC","TextFieldName","mainField1","mainField2","mainField3","mainField4","statusBar","mediaClock","mediaTrack","templateTitle","alertText1","alertText2","alertText3","scrollableMessageBody","initialInteractionText","navigationText1","navigationText2","ETA","totalDistance","audioPassThruDisplayText1","audioPassThruDisplayText2","sliderHeader","sliderFooter","menuName","secondaryText","tertiaryText","menuTitle","locationName","locationDescription","addressLines","phoneNumber","CharacterSet","TYPE2SET","TYPE5SET","CID1SET","CID2SET","TextField","setCharacterSet","KEY_CHARACTER_SET","getCharacterSet","setWidth","KEY_WIDTH","getWidth","setRows","rows","KEY_ROWS","getRows","DisplayCapabilities","setDisplayType","KEY_DISPLAY_TYPE","getDisplayType","setDisplayName","KEY_DISPLAY_NAME","getDisplayName","setTextFields","KEY_TEXT_FIELDS","getTextFields","setImageFields","KEY_IMAGE_FIELDS","getImageFields","setMediaClockFormats","formats","KEY_MEDIA_CLOCK_FORMATS","getMediaClockFormats","setGraphicSupported","KEY_GRAPHIC_SUPPORTED","getGraphicSupported","setTemplatesAvailable","KEY_TEMPLATES_AVAILABLE","getTemplatesAvailable","setScreenParams","KEY_SCREEN_PARAMS","getScreenParams","setNumCustomPresetsAvailable","KEY_NUM_CUSTOM_PRESETS_AVAILABLE","getNumCustomPresetsAvailable","SamplingRate","SamplingRate_8KHZ","SamplingRate_16KHZ","SamplingRate_22KHZ","SamplingRate_44KHZ","BitsPerSample","BitsPerSample_8_BIT","BitsPerSample_16_BIT","AudioType","PCM","AudioPassThruCapabilities","setSamplingRate","rate","KEY_SAMPLING_RATE","getSamplingRate","setBitsPerSample","sample","KEY_BITS_PER_SAMPLE","getBitsPerSample","setAudioType","KEY_AUDIO_TYPE","getAudioType","VrCapabilities","VR_TEXT","ButtonName","OK","PLAY_PAUSE","SEEKLEFT","SEEKRIGHT","TUNEUP","TUNEDOWN","PRESET_0","PRESET_1","PRESET_2","PRESET_3","PRESET_4","PRESET_5","PRESET_6","PRESET_7","PRESET_8","PRESET_9","CUSTOM_BUTTON","SEARCH","AC_MAX","AC","RECIRCULATE","FAN_UP","FAN_DOWN","TEMP_UP","TEMP_DOWN","DEFROST_MAX","DEFROST","DEFROST_REAR","UPPER_VENT","LOWER_VENT","VOLUME_UP","VOLUME_DOWN","EJECT","SOURCE","SHUFFLE","REPEAT","NAV_CENTER_LOCATION","NAV_ZOOM_IN","NAV_ZOOM_OUT","NAV_PAN_UP","NAV_PAN_UP_RIGHT","NAV_PAN_RIGHT","NAV_PAN_DOWN_RIGHT","NAV_PAN_DOWN","NAV_PAN_DOWN_LEFT","NAV_PAN_LEFT","NAV_PAN_UP_LEFT","NAV_TILT_TOGGLE","NAV_ROTATE_CLOCKWISE","NAV_ROTATE_COUNTERCLOCKWISE","NAV_HEADING_TOGGLE","Grid","setColumn","col","KEY_COLUMN","getColumn","setRow","row","KEY_ROW","getRow","setLevel","level","KEY_LEVEL","getLevel","setColumnSpan","colspan","KEY_COLUMN_SPAN","getColumnSpan","setRowSpan","rowspan","KEY_ROW_SPAN","getRowSpan","setLevelSpan","levelspan","KEY_LEVEL_SPAN","getLevelSpan","ModuleInfo","setModuleId","KEY_MODULE_ID","getModuleId","setLocation","location","KEY_LOCATION","getLocation","setServiceArea","area","KEY_SERVICE_AREA","getServiceArea","setAllowMultipleAccess","access","KEY_ALLOW_MULTIPLE_ACCESS","getAllowMultipleAccess","ButtonCapabilities","setModuleInfo","KEY_MODULE_INFO","getModuleInfo","HMICapabilities","setNavigation","navigation","KEY_NAVIGATION","getNavigation","setPhoneCall","KEY_PHONE_CALL","getPhoneCall","setVideoStreaming","streaming","KEY_VIDEO_STREAMING","getVideoStreaming","setRemoteControl","control","KEY_REMOTE_CONTROL","getRemoteControl","setAppServices","services","KEY_APP_SERVICES","getAppServices","setDisplays","displays","KEY_DISPLAYS","getDisplays","setSeatLocation","KEY_SEAT_LOCATION","getSeatLocation","RegisterAppInterfaceResponse","setLanguage","language","KEY_LANGUAGE","getLanguage","setHmiDisplayLanguage","KEY_HMI_DISPLAY_LANGUAGE","getHmiDisplayLanguage","setDisplayCapabilities","capabilities","KEY_DISPLAY_CAPABILITIES","getDisplayCapabilities","setButtonCapabilities","KEY_BUTTON_CAPABILITIES","getButtonCapabilities","setSoftButtonCapabilities","KEY_SOFT_BUTTON_CAPABILITIES","getSoftButtonCapabilities","setPresetBankCapabilities","KEY_PRESET_BANK_CAPABILITIES","getPresetBankCapabilities","setHmiZoneCapabilities","KEY_HMI_ZONE_CAPABILITIES","getHmiZoneCapabilities","setSpeechCapabilities","KEY_SPEECH_CAPABILITIES","getSpeechCapabilities","setPrerecordedSpeech","speech","KEY_PRERECORDED_SPEECH","getPrerecordedSpeech","setVrCapabilities","KEY_VR_CAPABILITIES","getVrCapabilities","setAudioPassThruCapabilities","KEY_AUDIO_PASS_THRU_CAPABILITIES","getAudioPassThruCapabilities","setPcmStreamCapabilities","KEY_PCM_STREAM_CAPABILITIES","getPcmStreamCapabilities","setVehicleType","KEY_VEHICLE_TYPE","getVehicleType","setSupportedDiagModes","modes","KEY_SUPPORTED_DIAG_MODES","getSupportedDiagModes","setHmiCapabilities","KEY_HMI_CAPABILITIES","getHmiCapabilities","setSdlVersion","KEY_SDL_VERSION","getSdlVersion","setSystemSoftwareVersion","KEY_SYSTEM_SOFTWARE_VERSION","getSystemSoftwareVersion","setIconResumed","resumed","KEY_ICON_RESUMED","getIconResumed","UnregisterAppInterfaceResponse","WindowType","MAIN","WIDGET","setWindowID","KEY_WINDOW_ID","getWindowID","setWindowName","KEY_WINDOW_NAME","getWindowName","setAssociatedServiceType","KEY_ASSOCIATED_SERVICE_TYPE","getAssociatedServiceType","setDuplicateUpdatesFromWindowID","KEY_DUPLICATE_UPDATES_FROM_WINDOW_ID","getDuplicateUpdatesFromWindowID","CreateWindowResponse","DeleteWindowResponse","ImageType","STATIC","DYNAMIC","Image","setValue","KEY_VALUE","getValue","setImageType","KEY_IMAGE_TYPE","getImageType","setIsTemplate","template","KEY_IS_TEMPLATE","getIsTemplate","VrHelpItem","setImage","image","KEY_IMAGE","getImage","setPosition","KEY_POSITION","getPosition","SeatLocation","setGrid","grid","KEY_GRID","getGrid","MenuLayout","LIST","TILES","KeyboardLayout","QWERTY","QWERTZ","AZERTY","KeypressMode","SINGLE_KEYPRESS","QUEUE_KEYPRESSES","RESEND_CURRENT_ENTRY","KeyboardProperties","setKeyboardLayout","layout","KEY_KEYBOARD_LAYOUT","getKeyboardLayout","setKeypressMode","mode","KEY_KEYPRESS_MODE","getKeypressMode","setLimitedCharacterList","KEY_LIMITED_CHARACTER_LIST","getLimitedCharacterList","setAutoCompleteText","KEY_AUTO_COMPLETE_TEXT","getAutoCompleteText","setAutoCompleteList","KEY_AUTO_COMPLETE_LIST","getAutoCompleteList","setUserLocation","KEY_USER_LOCATION","getUserLocation","setHelpPrompt","prompt","KEY_HELP_PROMPT","getHelpPrompt","setTimeoutPrompt","KEY_TIMEOUT_PROMPT","getTimeoutPrompt","setVrHelpTitle","title","KEY_VR_HELP_TITLE","getVrHelpTitle","setVrHelp","help","KEY_VR_HELP","getVrHelp","setMenuTitle","KEY_MENU_TITLE","getMenuTitle","setMenuIcon","KEY_MENU_ICON","getMenuIcon","setKeyboardProperties","properties","KEY_KEYBOARD_PROPERTIES","getKeyboardProperties","setMenuLayout","KEY_MENU_LAYOUT","getMenuLayout","SetGlobalPropertiesResponse","GlobalProperty","USER_LOCATION","HELPPROMPT","TIMEOUTPROMPT","VRHELPTITLE","VRHELPITEMS","MENUNAME","MENUICON","KEYBOARDPROPERTIES","setProperties","KEY_PROPERTIES","getProperties","ResetGlobalPropertiesResponse","MenuParams","setParentID","KEY_PARENT_ID","getParentID","setMenuName","KEY_MENU_NAME","getMenuName","setCmdID","KEY_CMD_ID","getCmdID","setMenuParams","KEY_MENU_PARAMS","getMenuParams","setVrCommands","commands","KEY_VR_COMMANDS","getVrCommands","setCmdIcon","KEY_CMD_ICON","getCmdIcon","AddCommandResponse","DeleteCommandResponse","setMenuID","KEY_MENU_ID","getMenuID","AddSubMenuResponse","DeleteSubMenuResponse","ShowAppMenuResponse","Choice","setChoiceID","KEY_CHOICE_ID","getChoiceID","setSecondaryText","KEY_SECONDARY_TEXT","getSecondaryText","setTertiaryText","KEY_TERTIARY_TEXT","getTertiaryText","setSecondaryImage","KEY_SECONDARY_IMAGE","getSecondaryImage","setInteractionChoiceSetID","KEY_INTERACTION_CHOICE_SET_ID","getInteractionChoiceSetID","setChoiceSet","KEY_CHOICE_SET","getChoiceSet","CreateInteractionChoiceSetResponse","LayoutMode","ICON_ONLY","ICON_WITH_SEARCH","LIST_ONLY","LIST_WITH_SEARCH","KEYBOARD","InteractionMode","MANUAL_ONLY","VR_ONLY","BOTH","setInitialText","KEY_INITIAL_TEXT","getInitialText","setInitialPrompt","KEY_INITIAL_PROMPT","getInitialPrompt","setInteractionMode","KEY_INTERACTION_MODE","getInteractionMode","setInteractionChoiceSetIDList","KEY_INTERACTION_CHOICE_SET_IDLIST","getInteractionChoiceSetIDList","timeout","KEY_TIMEOUT","getTimeout","setInteractionLayout","KEY_INTERACTION_LAYOUT","getInteractionLayout","setCancelID","KEY_CANCEL_ID","getCancelID","TriggerSource","TS_MENU","TS_VR","TS_KEYBOARD","PerformInteractionResponse","setManualTextEntry","KEY_MANUAL_TEXT_ENTRY","getManualTextEntry","setTriggerSource","KEY_TRIGGER_SOURCE","getTriggerSource","DeleteInteractionChoiceSetResponse","SoftButtonType","SBT_TEXT","SBT_IMAGE","SBT_BOTH","SystemAction","DEFAULT_ACTION","STEAL_FOCUS","KEEP_CONTEXT","SoftButton","setIsHighlighted","highlighted","KEY_IS_HIGHLIGHTED","getIsHighlighted","setSoftButtonID","KEY_SOFT_BUTTON_ID","getSoftButtonID","setSystemAction","action","KEY_SYSTEM_ACTION","getSystemAction","setAlertText1","text1","KEY_ALERT_TEXT_1","getAlertText1","setAlertText2","text2","KEY_ALERT_TEXT_2","getAlertText2","setAlertText3","text3","KEY_ALERT_TEXT_3","getAlertText3","setTtsChunks","chunks","KEY_TTS_CHUNKS","getTtsChunks","setDuration","duration","KEY_DURATION","getDuration","setPlayTone","tone","KEY_PLAY_TONE","getPlayTone","setProgressIndicator","indicator","KEY_PROGRESS_INDICATOR","getProgressIndicator","setSoftButtons","buttons","KEY_SOFT_BUTTONS","getSoftButtons","setAlertIcon","KEY_ALERT_ICON","getAlertIcon","AlertResponse","setTryAgainTime","KEY_TRY_AGAIN_TIME","getTryAgainTime","TextAlignment","LEFT_ALIGNED","RIGHT_ALIGNED","CENTERED","TemplateConfiguration","setTemplate","KEY_TEMPLATE","getTemplate","MetadataType","mediaTitle","mediaArtist","mediaAlbum","mediaYear","mediaGenre","mediaStation","rating","currentTemperature","maximumTemperature","minimumTemperature","weatherTerm","humidity","MetadataTags","setMainField1","field1","KEY_MAIN_FIELD_1","getMainField1","setMainField2","field2","KEY_MAIN_FIELD_2","getMainField2","setMainField3","field3","KEY_MAIN_FIELD_3","getMainField3","setMainField4","field4","KEY_MAIN_FIELD_4","getMainField4","setAlignment","alignment","KEY_ALIGNMENT","getAlignment","setStatusBar","bar","KEY_STATUS_BAR","getStatusBar","setMediaClock","clock","KEY_MEDIA_CLOCK","getMediaClock","setMediaTrack","track","KEY_MEDIA_TRACK","getMediaTrack","setGraphic","KEY_GRAPHIC","getGraphic","setSecondaryGraphic","KEY_SECONDARY_GRAPHIC","getSecondaryGraphic","setCustomPresets","presets","KEY_CUSTOM_PRESETS","getCustomPresets","setMetadataTags","tags","KEY_METADATA_TAGS","getMetadataTags","setTemplateTitle","KEY_TEMPLATE_TITLE","getTemplateTitle","setTemplateConfiguration","configuration","KEY_TEMPLATE_CONFIGURATION","getTemplateConfiguration","ShowResponse","SpeakResponse","StartTime","setHours","hours","KEY_HOURS","setMinutes","minutes","KEY_MINUTES","setSeconds","seconds","KEY_SECONDS","UpdateMode","COUNTUP","COUNTDOWN","PAUSE","RESUME","CLEAR","AudioStreamingIndicator","PLAY","STOP","setStartTime","KEY_START_TIME","getStartTime","setEndTime","KEY_END_TIME","getEndTime","setUpdateMode","KEY_UPDATE_MODE","getUpdateMode","setAudioStreamingIndicator","KEY_AUDIO_STREAMING_INDICATOR","getAudioStreamingIndicator","SetMediaClockTimerResponse","setAudioPassThruDisplayText1","KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_1","getAudioPassThruDisplayText1","setAudioPassThruDisplayText2","KEY_AUDIO_PASS_THRU_DISPLAY_TEXT_2","getAudioPassThruDisplayText2","setMaxDuration","KEY_MAX_DURATION","getMaxDuration","setMuteAudio","audio","KEY_MUTE_AUDIO","getMuteAudio","PerformAudioPassThruResponse","EndAudioPassThruResponse","setButtonName","KEY_BUTTON_NAME","getButtonName","SubscribeButtonResponse","UnsubscribeButtonResponse","setGps","gps","KEY_GPS","getGps","setSpeed","speed","KEY_SPEED","getSpeed","setRpm","rpm","KEY_RPM","getRpm","setFuelLevel","KEY_FUEL_LEVEL","getFuelLevel","setFuelLevel_State","level_state","KEY_FUEL_LEVEL_STATE","getFuelLevel_State","setInstantFuelConsumption","consumption","KEY_INSTANT_FUEL_CONSUMPTION","getInstantFuelConsumption","setFuelRange","range","KEY_FUEL_RANGE","getFuelRange","setExternalTemperature","temperature","KEY_EXTERNAL_TEMPERATURE","getExternalTemperature","setTurnSignal","signal","KEY_TURN_SIGNAL","getTurnSignal","setPrndl","prndl","KEY_PRNDL","getPrndl","setTirePressure","pressure","KEY_TIRE_PRESSURE","getTirePressure","setOdometer","odometer","KEY_ODOMETER","getOdometer","setBeltStatus","status","KEY_BELT_STATUS","getBeltStatus","setBodyInformation","information","KEY_BODY_INFORMATION","getBodyInformation","setDeviceStatus","KEY_DEVICE_STATUS","getDeviceStatus","setDriverBraking","braking","KEY_DRIVER_BRAKING","getDriverBraking","setWiperStatus","KEY_WIPER_STATUS","getWiperStatus","setHeadLampStatus","KEY_HEAD_LAMP_STATUS","getHeadLampStatus","setEngineTorque","torque","KEY_ENGINE_TORQUE","getEngineTorque","setAccPedalPosition","KEY_ACC_PEDAL_POSITION","getAccPedalPosition","setSteeringWheelAngle","angle","KEY_STEERING_WHEEL_ANGLE","getSteeringWheelAngle","setEngineOilLife","life","KEY_ENGINE_OIL_LIFE","getEngineOilLife","setElectronicParkBrakeStatus","KEY_ELECTRONIC_PARK_BRAKE_STATUS","getElectronicParkBrakeStatus","setCloudAppVehicleID","KEY_CLOUD_APP_VEHICLE_ID","getCloudAppVehicleID","setECallInfo","KEY_E_CALL_INFO","getECallInfo","setAirbagStatus","KEY_AIRBAG_STATUS","getAirbagStatus","setEmergencyEvent","event","KEY_EMERGENCY_EVENT","getEmergencyEvent","setClusterModeStatus","KEY_CLUSTER_MODE_STATUS","getClusterModeStatus","setMyKey","KEY_MY_KEY","getMyKey","VehicleDataResultCode","VDRC_SUCCESS","VDRC_TRUNCATED_DATA","VDRC_DISALLOWED","VDRC_USER_DISALLOWED","VDRC_INVALID_ID","VDRC_DATA_NOT_AVAILABLE","VDRC_DATA_ALREADY_SUBSCRIBED","VDRC_DATA_NOT_SUBSCRIBED","VDRC_IGNORED","VehicleDataType","VEHICLEDATA_GPS","VEHICLEDATA_SPEED","VEHICLEDATA_RPM","VEHICLEDATA_FUELLEVEL","VEHICLEDATA_FUELLEVEL_STATE","VEHICLEDATA_FUELCONSUMPTION","VEHICLEDATA_EXTERNTEMP","VEHICLEDATA_VIN","VEHICLEDATA_PRNDL","VEHICLEDATA_TIREPRESSURE","VEHICLEDATA_ODOMETER","VEHICLEDATA_BELTSTATUS","VEHICLEDATA_BODYINFO","VEHICLEDATA_DEVICESTATUS","VEHICLEDATA_ECALLINFO","VEHICLEDATA_AIRBAGSTATUS","VEHICLEDATA_EMERGENCYEVENT","VEHICLEDATA_CLUSTERMODESTATUS","VEHICLEDATA_MYKEY","VEHICLEDATA_BRAKING","VEHICLEDATA_WIPERSTATUS","VEHICLEDATA_HEADLAMPSTATUS","VEHICLEDATA_BATTVOLTAGE","VEHICLEDATA_ENGINETORQUE","VEHICLEDATA_ACCPEDAL","VEHICLEDATA_STEERINGWHEEL","VEHICLEDATA_TURNSIGNAL","VEHICLEDATA_FUELRANGE","VEHICLEDATA_ENGINEOILLIFE","VEHICLEDATA_ELECTRONICPARKBRAKESTATUS","VEHICLEDATA_CLOUDAPPVEHICLEID","VEHICLEDATA_OEM_CUSTOM_DATA","VehicleDataResult","setDataType","KEY_DATA_TYPE","getDataType","setOemCustomDataType","KEY_OEM_CUSTOM_DATA_TYPE","getOemCustomDataType","SubscribeVehicleDataResponse","setClusterModes","KEY_CLUSTER_MODES","getClusterModes","UnsubscribeVehicleDataResponse","setVin","vin","KEY_VIN","getVin","VehicleDataEventStatus","VDES_NO_EVENT","VDES_NO","VDES_YES","VDES_NOT_SUPPORTED","VDES_FAULT","AirbagStatus","setDriverAirbagDeployed","deployed","KEY_DRIVER_AIRBAG_DEPLOYED","getDriverAirbagDeployed","setDriverSideAirbagDeployed","KEY_DRIVER_SIDE_AIRBAG_DEPLOYED","getDriverSideAirbagDeployed","setDriverCurtainAirbagDeployed","KEY_DRIVER_CURTAIN_AIRBAG_DEPLOYED","getDriverCurtainAirbagDeployed","setPassengerAirbagDeployed","KEY_PASSENGER_AIRBAG_DEPLOYED","getPassengerAirbagDeployed","setPassengerCurtainAirbagDeployed","KEY_PASSENGER_CURTAIN_AIRBAG_DEPLOYED","getPassengerCurtainAirbagDeployed","setDriverKneeAirbagDeployed","KEY_DRIVER_KNEE_AIRBAG_DEPLOYED","getDriverKneeAirbagDeployed","setPassengerSideAirbagDeployed","KEY_PASSENGER_SIDE_AIRBAG_DEPLOYED","getPassengerSideAirbagDeployed","setPassengerKneeAirbagDeployed","KEY_PASSENGER_KNEE_AIRBAG_DEPLOYED","getPassengerKneeAirbagDeployed","PowerModeStatus","KEY_OUT","KEY_RECENTLY_OUT","KEY_APPROVED_0","POST_ACCESORY_0","ACCESORY_1","POST_IGNITION_1","IGNITION_ON_2","RUNNING_2","CRANK_3","CarModeStatus","CMS_NORMAL","CMS_FACTORY","CMS_TRANSPORT","CMS_CRASH","PowerModeQualificationStatus","POWER_MODE_UNDEFINED","POWER_MODE_EVALUATION_IN_PROGRESS","NOT_DEFINED","POWER_MODE_OK","ClusterModeStatus","setPowerModeActive","active","KEY_POWER_MODE_ACTIVE","getPowerModeActive","setPowerModeQualificationStatus","KEY_POWER_MODE_QUALIFICATION_STATUS","getPowerModeQualificationStatus","setCarModeStatus","KEY_CAR_MODE_STATUS","getCarModeStatus","setPowerModeStatus","KEY_POWER_MODE_STATUS","getPowerModeStatus","FuelCutoffStatus","FCS_TERMINATE_FUEL","FCS_NORMAL_OPERATION","FCS_FAULT","EmergencyEventType","EET_NO_EVENT","EET_FRONTAL","EET_SIDE","EET_REAR","EET_ROLLOVER","EET_NOT_SUPPORTED","EET_FAULT","EmergencyEvent","setEmergencyEventType","KEY_EMERGENCY_EVENT_TYPE","getEmergencyEventType","setFuelCutoffStatus","KEY_FUEL_CUTOFF_STATUS","getFuelCutoffStatus","setRolloverEvent","KEY_ROLLOVER_EVENT","getRolloverEvent","setMaximumChangeVelocity","velocity","KEY_MAXIMUM_CHANGE_VELOCITY","getMaximumChangeVelocity","setMultipleEvents","events","KEY_MULTIPLE_EVENTS","getMultipleEvents","TurnSignal","OFF","LEFT","RIGHT","AmbientLightStatus","NIGHT","TWILIGHT_1","TWILIGHT_2","TWILIGHT_3","TWILIGHT_4","DAY","ALS_UNKNOWN","INVALID","HeadLampStatus","setLowBeamsOn","on","KEY_LOW_BEAMS_ON","getLowBeamsOn","setHighBeamsOn","KEY_HIGH_BEAMS_ON","getHighBeamsOn","setAmbientLightSensorStatus","KEY_AMBIENT_LIGHT_SENSOR_STATUS","getAmbientLightSensorStatus","PrimaryAudioSource","NO_SOURCE_SELECTED","CD","USB","USB2","BLUETOOTH_STEREO_BTST","LINE_IN","IPOD","MOBILE_APP","AM","FM","XM","DAB","DeviceLevelStatus","ZERO_LEVEL_BARS","ONE_LEVEL_BARS","TWO_LEVEL_BARS","THREE_LEVEL_BARS","FOUR_LEVEL_BARS","NOT_PROVIDED","DeviceStatus","setVoiceRecOn","KEY_VOICE_REC_ON","getVoiceRecOn","setBtIconOn","KEY_BT_ICON_ON","getBtIconOn","setCallActive","KEY_CALL_ACTIVE","getCallActive","setPhoneRoaming","roaming","KEY_PHONE_ROAMING","getPhoneRoaming","setTextMsgAvailable","KEY_TEXT_MSG_AVAILABLE","getTextMsgAvailable","setBattLevelStatus","KEY_BATT_LEVEL_STATUS","getBattLevelStatus","setStereoAudioOutputMuted","muted","KEY_STEREO_AUDIO_OUTPUT_MUTED","getStereoAudioOutputMuted","setMonoAudioOutputMuted","KEY_MONO_AUDIO_OUTPUT_MUTED","getMonoAudioOutputMuted","setSignalLevelStatus","KEY_SIGNAL_LEVEL_STATUS","getSignalLevelStatus","setPrimaryAudioSource","KEY_PRIMARY_AUDIO_SOURCE","getPrimaryAudioSource","setECallEventActive","KEY_E_CALL_EVENT_ACTIVE","getECallEventActive","WiperStatus","AUTO_OFF","OFF_MOVING","MAN_INT_OFF","MAN_INT_ON","MAN_LOW","MAN_HIGH","MAN_FLICK","WASH","AUTO_LOW","AUTO_HIGH","COURTESYWIPE","AUTO_ADJUST","STALLED","NO_DATA_EXISTS","ElectronicParkBrakeStatus","CLOSED","TRANSITION","OPEN","DRIVE_ACTIVE","FAULT","VehicleDataStatus","VDS_NO_DATA_EXISTS","VDS_OFF","VDS_ON","MyKey","setE911Override","e911override","KEY_E911OVERRIDE","getE911Override","CompassDirection","NORTH","NORTHWEST","WEST","SOUTHWEST","SOUTH","SOUTHEAST","EAST","NORTHEAST","Dimension","Dimension_NO_FIX","Dimension_2D","Dimension_3D","GPSData","setLongitudeDegrees","degrees","KEY_LONGITUDE_DEGREES","getLongitudeDegrees","setLatitudeDegrees","KEY_LATITUDE_DEGREES","getLatitudeDegrees","setUtcYear","KEY_UTC_YEAR","getUtcYear","setUtcMonth","month","KEY_UTC_MONTH","getUtcMonth","setUtcDay","day","KEY_UTC_DAY","getUtcDay","setUtcHours","KEY_UTC_HOURS","getUtcHours","setUtcMinutes","KEY_UTC_MINUTES","getUtcMinutes","setUtcSeconds","KEY_UTC_SECONDS","getUtcSeconds","setCompassDirection","direction","KEY_COMPASS_DIRECTION","getCompassDirection","setPdop","pdop","KEY_PDOP","getPdop","setHdop","hdop","KEY_HDOP","getHdop","setVdop","vdop","KEY_VDOP","getVdop","setActual","KEY_ACTUAL","getActual","setSatellites","satellites","KEY_SATELLITES","getSatellites","setDimension","dimension","KEY_DIMENSION","getDimension","setAltitude","altitude","KEY_ALTITUDE","getAltitude","setHeading","heading","KEY_HEADING","getHeading","setShifted","shifted","KEY_SHIFTED","getShifted","PRNDL","PARK","REVERSE","NEUTRAL","DRIVE","SPORT","LOWGEAR","SECOND","THIRD","FOURTH","FIFTH","SIXTH","SEVENTH","EIGHTH","UNKNOWN","FuelType","GASOLINE","DIESEL","CNG","LPG","HYDROGEN","BATTERY","FuelRange","setRange","KEY_RANGE","getRange","VehicleDataNotificationStatus","VDNS_NOT_SUPPORTED","VDNS_NORMAL","VDNS_ACTIVE","VDNS_NOT_USED","ECallConfirmationStatus","ECCS_NORMAL","ECCS_CALL_IN_PROGRESS","ECCS_CALL_CANCELLED","CALL_COMPLETED","ECCS_CALL_UNSUCCESSFUL","ECCS_ECALL_CONFIGURED_OFF","ECCS_CALL_COMPLETE_DTMF_TIMEOUT","ECallInfo","setECallNotificationStatus","KEY_E_CALL_NOTIFICATION_STATUS","getECallNotificationStatus","setAuxECallNotificationStatus","KEY_AUX_ECALL_NOTIFICATION_STATUS","getAuxECallNotificationStatus","setECallConfirmationStatus","KEY_E_CALL_CONFIRMATION_STATUS","getECallConfirmationStatus","BeltStatus","setDriverBeltDeployed","KEY_DRIVER_BELT_DEPLOYED","getDriverBeltDeployed","setPassengerBeltDeployed","KEY_PASSENGER_BELT_DEPLOYED","getPassengerBeltDeployed","setPassengerBuckleBelted","belted","KEY_PASSENGER_BUCKLE_BELTED","getPassengerBuckleBelted","setDriverBuckleBelted","KEY_DRIVER_BUCKLE_BELTED","getDriverBuckleBelted","setLeftRow2BuckleBelted","KEY_LEFT_ROW2BUCKLE_BELTED","getLeftRow2BuckleBelted","setPassengerChildDetected","detected","KEY_PASSENGER_CHILD_DETECTED","getPassengerChildDetected","setRightRow2BuckleBelted","KEY_RIGHT_ROW2BUCKLE_BELTED","getRightRow2BuckleBelted","setMiddleRow2BuckleBelted","KEY_MIDDLE_ROW2BUCKLE_BELTED","getMiddleRow2BuckleBelted","setMiddleRow3BuckleBelted","KEY_MIDDLE_ROW3BUCKLE_BELTED","getMiddleRow3BuckleBelted","setLeftRow3BuckleBelted","KEY_LEFT_ROW3BUCKLE_BELTED","getLeftRow3BuckleBelted","setRightRow3BuckleBelted","KEY_RIGHT_ROW3BUCKLE_BELTED","getRightRow3BuckleBelted","setLeftRearInflatableBelted","KEY_LEFT_REAR_INFLATABLE_BELTED","getLeftRearInflatableBelted","setRightRearInflatableBelted","KEY_RIGHT_REAR_INFLATABLE_BELTED","getRightRearInflatableBelted","setMiddleRow1BeltDeployed","KEY_MIDDLE_ROW1BELT_DEPLOYED","getMiddleRow1BeltDeployed","setMiddleRow1BuckleBelted","KEY_MIDDLE_ROW1BUCKLE_BELTED","getMiddleRow1BuckleBelted","ComponentVolumeStatus","CVS_UNKNOWN","CVS_NORMAL","CVS_LOW","CVS_FAULT","CVS_ALERT","CVS_NOT_SUPPORTED","IgnitionStatus","IS_UNKNOWN","IS_OFF","IS_ACCESSORY","IS_RUN","IS_START","IS_INVALID","IgnitionStableStatus","IGNITION_SWITCH_NOT_STABLE","IGNITION_SWITCH_STABLE","MISSING_FROM_TRANSMITTER","BodyInformation","setParkBrakeActive","KEY_PARK_BRAKE_ACTIVE","getParkBrakeActive","setIgnitionStableStatus","KEY_IGNITION_STABLE_STATUS","getIgnitionStableStatus","setIgnitionStatus","KEY_IGNITION_STATUS","getIgnitionStatus","setDriverDoorAjar","ajar","KEY_DRIVER_DOOR_AJAR","getDriverDoorAjar","setPassengerDoorAjar","KEY_PASSENGER_DOOR_AJAR","getPassengerDoorAjar","setRearLeftDoorAjar","KEY_REAR_LEFT_DOOR_AJAR","getRearLeftDoorAjar","setRearRightDoorAjar","KEY_REAR_RIGHT_DOOR_AJAR","getRearRightDoorAjar","TPMS","SYSTEM_FAULT","SENSOR_FAULT","LOW","SYSTEM_ACTIVE","TRAIN","TRAINING_COMPLETE","NOT_TRAINED","SingleTireStatus","setStatus","KEY_STATUS","getStatus","setTpms","tpms","KEY_TPMS","getTpms","setPressure","KEY_PRESSURE","getPressure","WarningLightStatus","WLS_OFF","WLS_ON","WLS_FLASH","WLS_NOT_USED","TireStatus","setPressureTelltale","telltale","KEY_PRESSURE_TELLTALE","getPressureTelltale","setLeftFront","front","KEY_LEFT_FRONT","getLeftFront","setRightFront","KEY_RIGHT_FRONT","getRightFront","setLeftRear","rear","KEY_LEFT_REAR","getLeftRear","setRightRear","KEY_RIGHT_REAR","getRightRear","setInnerLeftRear","KEY_INNER_LEFT_REAR","getInnerLeftRear","setInnerRightRear","KEY_INNER_RIGHT_REAR","getInnerRightRear","GetVehicleDataResponse","setEcuName","KEY_ECU_NAME","getEcuName","setDidLocation","KEY_DID_LOCATION","getDidLocation","DIDResult","setData","KEY_DATA","getData","ReadDIDResponse","setDidResult","KEY_DID_RESULT","getDidResult","setDtcMask","mask","KEY_DTC_MASK","getDtcMask","GetDTCsResponse","setEcuHeader","KEY_ECU_HEADER","getEcuHeader","setDtc","dtc","KEY_DTC","getDtc","setTargetID","KEY_TARGET_ID","getTargetID","setMessageLength","KEY_MESSAGE_LENGTH","getMessageLength","setMessageData","KEY_MESSAGE_DATA","getMessageData","DiagnosticMessageResponse","setMessageDataResult","KEY_MESSAGE_DATA_RESULT","getMessageDataResult","setScrollableMessageBody","body","KEY_SCROLLABLE_MESSAGE_BODY","getScrollableMessageBody","ScrollableMessageResponse","setNumTicks","ticks","KEY_NUM_TICKS","getNumTicks","setSliderHeader","KEY_SLIDER_HEADER","getSliderHeader","setSliderFooter","footer","KEY_SLIDER_FOOTER","getSliderFooter","SliderResponse","setSliderPosition","KEY_SLIDER_POSITION","getSliderPosition","setNavigationText1","KEY_NAVIGATION_TEXT_1","getNavigationText1","setNavigationText2","KEY_NAVIGATION_TEXT_2","getNavigationText2","setEta","eta","KEY_ETA","getEta","setTimeToDestination","destination","KEY_TIME_TO_DESTINATION","getTimeToDestination","setTotalDistance","distance","KEY_TOTAL_DISTANCE","getTotalDistance","setTurnIcon","KEY_TURN_ICON","getTurnIcon","setNextTurnIcon","KEY_NEXT_TURN_ICON","getNextTurnIcon","setDistanceToManeuver","maneuver","KEY_DISTANCE_TO_MANEUVER","getDistanceToManeuver","setDistanceToManeuverScale","scale","KEY_DISTANCE_TO_MANEUVER_SCALE","getDistanceToManeuverScale","setManeuverComplete","complete","KEY_MANEUVER_COMPLETE","getManeuverComplete","ShowConstantTBTResponse","AlertManeuverResponse","Turn","setNavigationText","KEY_NAVIGATION_TEXT","getNavigationText","setTurnList","KEY_TURN_LIST","getTurnList","UpdateTurnListResponse","ChangeRegistrationResponse","GenericResponseResponse","setFileData","getFileData","setFileName","KEY_FILE_NAME","getFileName","setFileType","KEY_FILE_TYPE","getFileType","setPersistentFile","file","KEY_PERSISTENT_FILE","getPersistentFile","setSystemFile","KEY_SYSTEM_FILE","getSystemFile","setOffset","KEY_OFFSET","getOffset","setLength","KEY_LENGTH","getLength","setCrc","crc","KEY_CRC","getCrc","PutFileResponse","setSpaceAvailable","KEY_SPACE_AVAILABLE","getSpaceAvailable","setAppServiceId","KEY_APP_SERVICE_ID","getAppServiceId","GetFileResponse","setSdlFileName","KEY_SDL_FILE_NAME","getSdlFileName","DeleteFileResponse","ListFilesResponse","setFilenames","filenames","KEY_FILENAMES","getFilenames","SetAppIconResponse","setDisplayLayout","KEY_DISPLAY_LAYOUT","getDisplayLayout","SetDisplayLayoutResponse","RequestType","HTTP","FILE_RESUME","AUTH_REQUEST","AUTH_CHALLENGE","AUTH_ACK","PROPRIETARY","QUERY_APPS","LAUNCH_APP","LOCK_SCREEN_ICON_URL","TRAFFIC_MESSAGE_CHANNEL","DRIVER_PROFILE","VOICE_SEARCH","PHONE","CLIMATE","SETTINGS","VEHICLE_DIAGNOSTICS","EMERGENCY","FOTA","OEM_SPECIFIC","ICON_URL","setRequestType","KEY_REQUEST_TYPE","getRequestType","setRequestSubType","KEY_REQUEST_SUB_TYPE","getRequestSubType","SystemRequestResponse","DeliveryMode","PROMPT","DESTINATION","QUEUE","DateTime","setMillisecond","millisecond","KEY_MILLISECOND","getMillisecond","setSecond","second","KEY_SECOND","getSecond","setMinute","minute","KEY_MINUTE","getMinute","setHour","hour","KEY_HOUR","getHour","setDay","KEY_DAY","getDay","setMonth","KEY_MONTH","setYear","KEY_YEAR","getYear","setTz_hour","tz_hour","KEY_TZ_HOUR","getTz_hour","setTz_minute","tz_minute","KEY_TZ_MINUTE","getTz_minute","OASISAddress","setCountryName","KEY_COUNTRY_NAME","getCountryName","setCountryCode","KEY_COUNTRY_CODE","getCountryCode","setPostalCode","KEY_POSTAL_CODE","getPostalCode","setAdministrativeArea","KEY_ADMINISTRATIVE_AREA","getAdministrativeArea","setSubAdministrativeArea","KEY_SUB_ADMINISTRATIVE_AREA","getSubAdministrativeArea","setLocality","locality","KEY_LOCALITY","getLocality","setSubLocality","KEY_SUB_LOCALITY","getSubLocality","setThoroughfare","thoroughfare","KEY_THOROUGHFARE","getThoroughfare","setSubThoroughfare","KEY_SUB_THOROUGHFARE","getSubThoroughfare","setLocationName","KEY_LOCATION_NAME","getLocationName","setLocationDescription","description","KEY_LOCATION_DESCRIPTION","getLocationDescription","setAddressLines","lines","KEY_ADDRESS_LINES","getAddressLines","setPhoneNumber","number","KEY_PHONE_NUMBER","getPhoneNumber","setLocationImage","KEY_LOCATION_IMAGE","getLocationImage","setTimeStamp","stamp","KEY_TIME_STAMP","getTimeStamp","setAddress","address","KEY_ADDRESS","getAddress","setDeliveryMode","KEY_DELIVERY_MODE","getDeliveryMode","SendLocationResponse","setNumber","KEY_NUMBER","getNumber","DialNumberResponse","ButtonPressMode","LONG","SHORT","ModuleType","RADIO","SEAT","LIGHT","HMI_SETTINGS","setModuleType","KEY_MODULE_TYPE","getModuleType","setButtonPressMode","KEY_BUTTON_PRESS_MODE","getButtonPressMode","ButtonPressResponse","setSubscribe","subscribe","KEY_SUBSCRIBE","getSubscribe","DisplayMode","AUTO","DistanceUnit","MILES","KILOMETERS","TemperatureUnit","FAHRENHEIT","CELSIUS","HMISettingsControlData","setDisplayMode","KEY_DISPLAY_MODE","getDisplayMode","setTemperatureUnit","unit","KEY_TEMPERATURE_UNIT","getTemperatureUnit","setDistanceUnit","KEY_DISTANCE_UNIT","getDistanceUnit","RadioBand","RdsData","setPS","ps","KEY_PS","getPS","setRT","KEY_RT","getRT","setCT","ct","KEY_CT","getCT","setPI","pi","KEY_PI","getPI","setPTY","pty","KEY_PTY","getPTY","setTP","tp","KEY_TP","getTP","setTA","ta","KEY_TA","getTA","setREG","reg","KEY_REG","getREG","RadioState","ACQUIRING","ACQUIRED","MULTICAST","NOT_FOUND","StationIDNumber","setFccFacilityId","KEY_FCC_FACILITY_ID","getFccFacilityId","SisData","setStationShortName","KEY_STATION_SHORT_NAME","getStationShortName","setStationIDNumber","KEY_STATION_IDNUMBER","getStationIDNumber","setStationLongName","KEY_STATION_LONG_NAME","getStationLongName","setStationLocation","KEY_STATION_LOCATION","getStationLocation","setStationMessage","KEY_STATION_MESSAGE","getStationMessage","RadioControlData","setFrequencyInteger","integer","KEY_FREQUENCY_INTEGER","getFrequencyInteger","setFrequencyFraction","fraction","KEY_FREQUENCY_FRACTION","getFrequencyFraction","setBand","band","KEY_BAND","getBand","setRdsData","KEY_RDS_DATA","getRdsData","setHdRadioEnable","enable","KEY_HD_RADIO_ENABLE","getHdRadioEnable","setAvailableHDs","ds","KEY_AVAILABLE_HDS","getAvailableHDs","setAvailableHdChannels","channels","KEY_AVAILABLE_HD_CHANNELS","getAvailableHdChannels","setHdChannel","channel","KEY_HD_CHANNEL","getHdChannel","setSignalStrength","strength","KEY_SIGNAL_STRENGTH","getSignalStrength","setSignalChangeThreshold","threshold","KEY_SIGNAL_CHANGE_THRESHOLD","getSignalChangeThreshold","setRadioEnable","KEY_RADIO_ENABLE","getRadioEnable","setState","state","KEY_STATE","getState","setSisData","KEY_SIS_DATA","getSisData","Temperature","setUnit","KEY_UNIT","getUnit","VentilationMode","UPPER","LOWER","NONE","DefrostZone","REAR","ALL","ClimateControlData","setFanSpeed","KEY_FAN_SPEED","getFanSpeed","setCurrentTemperature","KEY_CURRENT_TEMPERATURE","getCurrentTemperature","setDesiredTemperature","KEY_DESIRED_TEMPERATURE","getDesiredTemperature","setAcEnable","KEY_AC_ENABLE","getAcEnable","setCirculateAirEnable","KEY_CIRCULATE_AIR_ENABLE","getCirculateAirEnable","setAutoModeEnable","KEY_AUTO_MODE_ENABLE","getAutoModeEnable","setDefrostZone","zone","KEY_DEFROST_ZONE","getDefrostZone","setDualModeEnable","KEY_DUAL_MODE_ENABLE","getDualModeEnable","setAcMaxEnable","KEY_AC_MAX_ENABLE","getAcMaxEnable","setVentilationMode","KEY_VENTILATION_MODE","getVentilationMode","setHeatedSteeringWheelEnable","KEY_HEATED_STEERING_WHEEL_ENABLE","getHeatedSteeringWheelEnable","setHeatedWindshieldEnable","KEY_HEATED_WINDSHIELD_ENABLE","getHeatedWindshieldEnable","setHeatedRearWindowEnable","KEY_HEATED_REAR_WINDOW_ENABLE","getHeatedRearWindowEnable","setHeatedMirrorsEnable","KEY_HEATED_MIRRORS_ENABLE","getHeatedMirrorsEnable","setClimateEnable","KEY_CLIMATE_ENABLE","getClimateEnable","EqualizerSettings","setChannelId","KEY_CHANNEL_ID","getChannelId","setChannelName","KEY_CHANNEL_NAME","getChannelName","setChannelSetting","setting","KEY_CHANNEL_SETTING","getChannelSetting","AudioControlData","setSource","KEY_SOURCE","getSource","setKeepContext","context","KEY_KEEP_CONTEXT","getKeepContext","setVolume","volume","KEY_VOLUME","getVolume","setEqualizerSettings","settings","KEY_EQUALIZER_SETTINGS","getEqualizerSettings","MassageCushion","TOP_LUMBAR","MIDDLE_LUMBAR","BOTTOM_LUMBAR","BACK_BOLSTERS","SEAT_BOLSTERS","MassageCushionFirmness","setCushion","cushion","KEY_CUSHION","getCushion","setFirmness","firmness","KEY_FIRMNESS","getFirmness","SupportedSeat","DRIVER","FRONT_PASSENGER","SeatMemoryActionType","SAVE","RESTORE","SeatMemoryAction","setId","KEY_ID","getId","setLabel","label","KEY_LABEL","getLabel","setAction","KEY_ACTION","getAction","MassageZone","LUMBAR","SEAT_CUSHION","MassageMode","HIGH","MassageModeData","setMassageZone","KEY_MASSAGE_ZONE","getMassageZone","setMassageMode","KEY_MASSAGE_MODE","getMassageMode","SeatControlData","setHeatingEnabled","enabled","KEY_HEATING_ENABLED","getHeatingEnabled","setCoolingEnabled","KEY_COOLING_ENABLED","getCoolingEnabled","setHeatingLevel","KEY_HEATING_LEVEL","getHeatingLevel","setCoolingLevel","KEY_COOLING_LEVEL","getCoolingLevel","setHorizontalPosition","KEY_HORIZONTAL_POSITION","getHorizontalPosition","setVerticalPosition","KEY_VERTICAL_POSITION","getVerticalPosition","setFrontVerticalPosition","KEY_FRONT_VERTICAL_POSITION","getFrontVerticalPosition","setBackVerticalPosition","KEY_BACK_VERTICAL_POSITION","getBackVerticalPosition","setBackTiltAngle","KEY_BACK_TILT_ANGLE","getBackTiltAngle","setHeadSupportHorizontalPosition","KEY_HEAD_SUPPORT_HORIZONTAL_POSITION","getHeadSupportHorizontalPosition","setHeadSupportVerticalPosition","KEY_HEAD_SUPPORT_VERTICAL_POSITION","getHeadSupportVerticalPosition","setMassageEnabled","KEY_MASSAGE_ENABLED","getMassageEnabled","setMassageCushionFirmness","KEY_MASSAGE_CUSHION_FIRMNESS","getMassageCushionFirmness","setMemory","memory","KEY_MEMORY","getMemory","LightStatus","ON","RAMP_UP","RAMP_DOWN","LightName","FRONT_LEFT_HIGH_BEAM","FRONT_RIGHT_HIGH_BEAM","FRONT_LEFT_LOW_BEAM","FRONT_RIGHT_LOW_BEAM","FRONT_LEFT_PARKING_LIGHT","FRONT_RIGHT_PARKING_LIGHT","FRONT_LEFT_FOG_LIGHT","FRONT_RIGHT_FOG_LIGHT","FRONT_LEFT_DAYTIME_RUNNING_LIGHT","FRONT_RIGHT_DAYTIME_RUNNING_LIGHT","FRONT_LEFT_TURN_LIGHT","FRONT_RIGHT_TURN_LIGHT","REAR_LEFT_FOG_LIGHT","REAR_RIGHT_FOG_LIGHT","REAR_LEFT_TAIL_LIGHT","REAR_RIGHT_TAIL_LIGHT","REAR_LEFT_BRAKE_LIGHT","REAR_RIGHT_BRAKE_LIGHT","REAR_LEFT_TURN_LIGHT","REAR_RIGHT_TURN_LIGHT","REAR_REGISTRATION_PLATE_LIGHT","HIGH_BEAMS","LOW_BEAMS","FOG_LIGHTS","RUNNING_LIGHTS","PARKING_LIGHTS","BRAKE_LIGHTS","REAR_REVERSING_LIGHTS","SIDE_MARKER_LIGHTS","LEFT_TURN_LIGHTS","RIGHT_TURN_LIGHTS","HAZARD_LIGHTS","REAR_CARGO_LIGHTS","REAR_TRUCK_BED_LIGHTS","REAR_TRAILER_LIGHTS","LEFT_SPOT_LIGHTS","RIGHT_SPOT_LIGHTS","LEFT_PUDDLE_LIGHTS","RIGHT_PUDDLE_LIGHTS","AMBIENT_LIGHTS","OVERHEAD_LIGHTS","READING_LIGHTS","TRUNK_LIGHTS","EXTERIOR_FRONT_LIGHTS","EXTERIOR_REAR_LIGHTS","EXTERIOR_LEFT_LIGHTS","EXTERIOR_RIGHT_LIGHTS","EXTERIOR_ALL_LIGHTS","LightState","setDensity","density","KEY_DENSITY","getDensity","setColor","KEY_COLOR","getColor","LightControlData","setLightState","KEY_LIGHT_STATE","getLightState","ModuleData","setRadioControlData","KEY_RADIO_CONTROL_DATA","getRadioControlData","setClimateControlData","KEY_CLIMATE_CONTROL_DATA","getClimateControlData","setSeatControlData","KEY_SEAT_CONTROL_DATA","getSeatControlData","setAudioControlData","KEY_AUDIO_CONTROL_DATA","getAudioControlData","setLightControlData","KEY_LIGHT_CONTROL_DATA","getLightControlData","setHmiSettingsControlData","KEY_HMI_SETTINGS_CONTROL_DATA","getHmiSettingsControlData","GetInteriorVehicleDataResponse","setModuleData","KEY_MODULE_DATA","getModuleData","setIsSubscribed","subscribed","KEY_IS_SUBSCRIBED","getIsSubscribed","setModuleIds","ids","KEY_MODULE_IDS","getModuleIds","GetInteriorVehicleDataConsentResponse","setAllowed","allowed","KEY_ALLOWED","getAllowed","ReleaseInteriorVehicleDataModuleResponse","SetInteriorVehicleDataResponse","SubscribeWayPointsResponse","WayPointType","setWayPointType","KEY_WAY_POINT_TYPE","getWayPointType","Coordinate","LocationDetails","setCoordinate","coordinate","KEY_COORDINATE","getCoordinate","setSearchAddress","KEY_SEARCH_ADDRESS","getSearchAddress","GetWayPointsResponse","setWayPoints","points","KEY_WAY_POINTS","getWayPoints","UnsubscribeWayPointsResponse","SystemCapabilityType","PHONE_CALL","VIDEO_STREAMING","APP_SERVICES","SEAT_LOCATION","DISPLAYS","setSystemCapabilityType","KEY_SYSTEM_CAPABILITY_TYPE","getSystemCapabilityType","VideoStreamingCodec","H264","H265","Theora","VP8","VP9","VideoStreamingProtocol","RAW","RTP","RTSP","RTMP","WEBM","VideoStreamingFormat","setProtocol","protocol","KEY_PROTOCOL","getProtocol","setCodec","codec","KEY_CODEC","getCodec","VideoStreamingCapability","setPreferredResolution","KEY_PREFERRED_RESOLUTION","getPreferredResolution","setMaxBitrate","bitrate","KEY_MAX_BITRATE","getMaxBitrate","setSupportedFormats","KEY_SUPPORTED_FORMATS","getSupportedFormats","setHapticSpatialDataSupported","KEY_HAPTIC_SPATIAL_DATA_SUPPORTED","getHapticSpatialDataSupported","setDiagonalScreenSize","KEY_DIAGONAL_SCREEN_SIZE","getDiagonalScreenSize","setPixelPerInch","inch","KEY_PIXEL_PER_INCH","getPixelPerInch","setScale","KEY_SCALE","getScale","PhoneCapability","setDialNumberEnabled","KEY_DIAL_NUMBER_ENABLED","getDialNumberEnabled","WindowTypeCapabilities","setMaximumNumberOfWindows","windows","KEY_MAXIMUM_NUMBER_OF_WINDOWS","getMaximumNumberOfWindows","WindowCapability","setMenuLayoutsAvailable","KEY_MENU_LAYOUTS_AVAILABLE","getMenuLayoutsAvailable","DisplayCapability","setWindowTypeSupported","KEY_WINDOW_TYPE_SUPPORTED","getWindowTypeSupported","setWindowCapabilities","KEY_WINDOW_CAPABILITIES","getWindowCapabilities","AudioControlCapabilities","setModuleName","KEY_MODULE_NAME","getModuleName","setSourceAvailable","KEY_SOURCE_AVAILABLE","getSourceAvailable","setKeepContextAvailable","KEY_KEEP_CONTEXT_AVAILABLE","getKeepContextAvailable","setVolumeAvailable","KEY_VOLUME_AVAILABLE","getVolumeAvailable","setEqualizerAvailable","KEY_EQUALIZER_AVAILABLE","getEqualizerAvailable","setEqualizerMaxChannelId","KEY_EQUALIZER_MAX_CHANNEL_ID","getEqualizerMaxChannelId","LightCapabilities","setStatusAvailable","KEY_STATUS_AVAILABLE","getStatusAvailable","setDensityAvailable","KEY_DENSITY_AVAILABLE","getDensityAvailable","setRgbColorSpaceAvailable","KEY_RGB_COLOR_SPACE_AVAILABLE","getRgbColorSpaceAvailable","LightControlCapabilities","setSupportedLights","lights","KEY_SUPPORTED_LIGHTS","getSupportedLights","ClimateControlCapabilities","setCurrentTemperatureAvailable","KEY_CURRENT_TEMPERATURE_AVAILABLE","getCurrentTemperatureAvailable","setFanSpeedAvailable","KEY_FAN_SPEED_AVAILABLE","getFanSpeedAvailable","setDesiredTemperatureAvailable","KEY_DESIRED_TEMPERATURE_AVAILABLE","getDesiredTemperatureAvailable","setAcEnableAvailable","KEY_AC_ENABLE_AVAILABLE","getAcEnableAvailable","setAcMaxEnableAvailable","KEY_AC_MAX_ENABLE_AVAILABLE","getAcMaxEnableAvailable","setCirculateAirEnableAvailable","KEY_CIRCULATE_AIR_ENABLE_AVAILABLE","getCirculateAirEnableAvailable","setAutoModeEnableAvailable","KEY_AUTO_MODE_ENABLE_AVAILABLE","getAutoModeEnableAvailable","setDualModeEnableAvailable","KEY_DUAL_MODE_ENABLE_AVAILABLE","getDualModeEnableAvailable","setDefrostZoneAvailable","KEY_DEFROST_ZONE_AVAILABLE","getDefrostZoneAvailable","setVentilationModeAvailable","KEY_VENTILATION_MODE_AVAILABLE","getVentilationModeAvailable","setHeatedSteeringWheelAvailable","KEY_HEATED_STEERING_WHEEL_AVAILABLE","getHeatedSteeringWheelAvailable","setHeatedWindshieldAvailable","KEY_HEATED_WINDSHIELD_AVAILABLE","getHeatedWindshieldAvailable","setHeatedRearWindowAvailable","KEY_HEATED_REAR_WINDOW_AVAILABLE","getHeatedRearWindowAvailable","setHeatedMirrorsAvailable","KEY_HEATED_MIRRORS_AVAILABLE","getHeatedMirrorsAvailable","setClimateEnableAvailable","KEY_CLIMATE_ENABLE_AVAILABLE","getClimateEnableAvailable","SeatControlCapabilities","setHeatingEnabledAvailable","KEY_HEATING_ENABLED_AVAILABLE","getHeatingEnabledAvailable","setCoolingEnabledAvailable","KEY_COOLING_ENABLED_AVAILABLE","getCoolingEnabledAvailable","setHeatingLevelAvailable","KEY_HEATING_LEVEL_AVAILABLE","getHeatingLevelAvailable","setCoolingLevelAvailable","KEY_COOLING_LEVEL_AVAILABLE","getCoolingLevelAvailable","setHorizontalPositionAvailable","KEY_HORIZONTAL_POSITION_AVAILABLE","getHorizontalPositionAvailable","setVerticalPositionAvailable","KEY_VERTICAL_POSITION_AVAILABLE","getVerticalPositionAvailable","setFrontVerticalPositionAvailable","KEY_FRONT_VERTICAL_POSITION_AVAILABLE","getFrontVerticalPositionAvailable","setBackVerticalPositionAvailable","KEY_BACK_VERTICAL_POSITION_AVAILABLE","getBackVerticalPositionAvailable","setBackTiltAngleAvailable","KEY_BACK_TILT_ANGLE_AVAILABLE","getBackTiltAngleAvailable","setHeadSupportHorizontalPositionAvailable","KEY_HEAD_SUPPORT_HORIZONTAL_POSITION_AVAILABLE","getHeadSupportHorizontalPositionAvailable","setHeadSupportVerticalPositionAvailable","KEY_HEAD_SUPPORT_VERTICAL_POSITION_AVAILABLE","getHeadSupportVerticalPositionAvailable","setMassageEnabledAvailable","KEY_MASSAGE_ENABLED_AVAILABLE","getMassageEnabledAvailable","setMassageModeAvailable","KEY_MASSAGE_MODE_AVAILABLE","getMassageModeAvailable","setMassageCushionFirmnessAvailable","KEY_MASSAGE_CUSHION_FIRMNESS_AVAILABLE","getMassageCushionFirmnessAvailable","setMemoryAvailable","KEY_MEMORY_AVAILABLE","getMemoryAvailable","RadioControlCapabilities","setRadioEnableAvailable","KEY_RADIO_ENABLE_AVAILABLE","getRadioEnableAvailable","setRadioBandAvailable","KEY_RADIO_BAND_AVAILABLE","getRadioBandAvailable","setRadioFrequencyAvailable","KEY_RADIO_FREQUENCY_AVAILABLE","getRadioFrequencyAvailable","setHdChannelAvailable","KEY_HD_CHANNEL_AVAILABLE","getHdChannelAvailable","setRdsDataAvailable","KEY_RDS_DATA_AVAILABLE","getRdsDataAvailable","setAvailableHDsAvailable","KEY_AVAILABLE_HDS_AVAILABLE","getAvailableHDsAvailable","setAvailableHdChannelsAvailable","KEY_AVAILABLE_HD_CHANNELS_AVAILABLE","getAvailableHdChannelsAvailable","setStateAvailable","KEY_STATE_AVAILABLE","getStateAvailable","setSignalStrengthAvailable","KEY_SIGNAL_STRENGTH_AVAILABLE","getSignalStrengthAvailable","setSignalChangeThresholdAvailable","KEY_SIGNAL_CHANGE_THRESHOLD_AVAILABLE","getSignalChangeThresholdAvailable","setSisDataAvailable","KEY_SIS_DATA_AVAILABLE","getSisDataAvailable","setHdRadioEnableAvailable","KEY_HD_RADIO_ENABLE_AVAILABLE","getHdRadioEnableAvailable","setSiriusxmRadioAvailable","KEY_SIRIUSXM_RADIO_AVAILABLE","getSiriusxmRadioAvailable","HMISettingsControlCapabilities","setDistanceUnitAvailable","KEY_DISTANCE_UNIT_AVAILABLE","getDistanceUnitAvailable","setTemperatureUnitAvailable","KEY_TEMPERATURE_UNIT_AVAILABLE","getTemperatureUnitAvailable","setDisplayModeUnitAvailable","KEY_DISPLAY_MODE_UNIT_AVAILABLE","getDisplayModeUnitAvailable","RemoteControlCapabilities","setClimateControlCapabilities","KEY_CLIMATE_CONTROL_CAPABILITIES","getClimateControlCapabilities","setRadioControlCapabilities","KEY_RADIO_CONTROL_CAPABILITIES","getRadioControlCapabilities","setAudioControlCapabilities","KEY_AUDIO_CONTROL_CAPABILITIES","getAudioControlCapabilities","setHmiSettingsControlCapabilities","KEY_HMI_SETTINGS_CONTROL_CAPABILITIES","getHmiSettingsControlCapabilities","setLightControlCapabilities","KEY_LIGHT_CONTROL_CAPABILITIES","getLightControlCapabilities","setSeatControlCapabilities","KEY_SEAT_CONTROL_CAPABILITIES","getSeatControlCapabilities","SeatLocationCapability","setColumns","columns","KEY_COLUMNS","getColumns","setLevels","levels","KEY_LEVELS","getLevels","setSeats","seats","KEY_SEATS","getSeats","ServiceUpdateReason","PUBLISHED","REMOVED","ACTIVATED","DEACTIVATED","MANIFEST_UPDATE","NavigationServiceManifest","setAcceptsWayPoints","KEY_ACCEPTS_WAY_POINTS","getAcceptsWayPoints","WeatherServiceManifest","setCurrentForecastSupported","KEY_CURRENT_FORECAST_SUPPORTED","getCurrentForecastSupported","setMaxMultidayForecastAmount","amount","KEY_MAX_MULTIDAY_FORECAST_AMOUNT","getMaxMultidayForecastAmount","setMaxHourlyForecastAmount","KEY_MAX_HOURLY_FORECAST_AMOUNT","getMaxHourlyForecastAmount","setMaxMinutelyForecastAmount","KEY_MAX_MINUTELY_FORECAST_AMOUNT","getMaxMinutelyForecastAmount","setWeatherForLocationSupported","KEY_WEATHER_FOR_LOCATION_SUPPORTED","getWeatherForLocationSupported","MediaServiceManifest","AppServiceManifest","setServiceName","KEY_SERVICE_NAME","getServiceName","setServiceType","KEY_SERVICE_TYPE","setServiceIcon","KEY_SERVICE_ICON","getServiceIcon","setAllowAppConsumers","consumers","KEY_ALLOW_APP_CONSUMERS","getAllowAppConsumers","setRpcSpecVersion","KEY_RPC_SPEC_VERSION","getRpcSpecVersion","setHandledRPCs","cs","KEY_HANDLED_RPCS","getHandledRPCs","setMediaServiceManifest","manifest","KEY_MEDIA_SERVICE_MANIFEST","getMediaServiceManifest","setWeatherServiceManifest","KEY_WEATHER_SERVICE_MANIFEST","getWeatherServiceManifest","setNavigationServiceManifest","KEY_NAVIGATION_SERVICE_MANIFEST","getNavigationServiceManifest","AppServiceRecord","setServiceID","KEY_SERVICE_ID","getServiceID","setServiceManifest","KEY_SERVICE_MANIFEST","getServiceManifest","setServicePublished","published","KEY_SERVICE_PUBLISHED","getServicePublished","setServiceActive","KEY_SERVICE_ACTIVE","getServiceActive","AppServiceCapability","setUpdateReason","KEY_UPDATE_REASON","getUpdateReason","setUpdatedAppServiceRecord","record","KEY_UPDATED_APP_SERVICE_RECORD","getUpdatedAppServiceRecord","AppServicesCapabilities","NavigationCapability","setSendLocationEnabled","KEY_SEND_LOCATION_ENABLED","getSendLocationEnabled","setGetWayPointsEnabled","KEY_GET_WAY_POINTS_ENABLED","getGetWayPointsEnabled","SystemCapability","setNavigationCapability","capability","KEY_NAVIGATION_CAPABILITY","getNavigationCapability","setPhoneCapability","KEY_PHONE_CAPABILITY","getPhoneCapability","setVideoStreamingCapability","KEY_VIDEO_STREAMING_CAPABILITY","getVideoStreamingCapability","setRemoteControlCapability","KEY_REMOTE_CONTROL_CAPABILITY","getRemoteControlCapability","setAppServicesCapabilities","KEY_APP_SERVICES_CAPABILITIES","getAppServicesCapabilities","setSeatLocationCapability","KEY_SEAT_LOCATION_CAPABILITY","getSeatLocationCapability","GetSystemCapabilityResponse","setSystemCapability","KEY_SYSTEM_CAPABILITY","getSystemCapability","Rectangle","setX","KEY_X","getX","setY","KEY_Y","getY","setHeight","KEY_HEIGHT","getHeight","HapticRect","setRect","rect","KEY_RECT","getRect","setHapticRectData","KEY_HAPTIC_RECT_DATA","getHapticRectData","SendHapticDataResponse","HybridAppPreference","MOBILE","CLOUD","CloudAppProperties","setNicknames","nicknames","KEY_NICKNAMES","getNicknames","setAppID","getAppID","setEnabled","KEY_ENABLED","getEnabled","setAuthToken","token","KEY_AUTH_TOKEN","getAuthToken","setCloudTransportType","KEY_CLOUD_TRANSPORT_TYPE","getCloudTransportType","setHybridAppPreference","preference","KEY_HYBRID_APP_PREFERENCE","getHybridAppPreference","setEndpoint","endpoint","KEY_ENDPOINT","getEndpoint","SetCloudAppPropertiesResponse","GetCloudAppPropertiesResponse","setAppServiceManifest","KEY_APP_SERVICE_MANIFEST","getAppServiceManifest","PublishAppServiceResponse","setAppServiceRecord","KEY_APP_SERVICE_RECORD","getAppServiceRecord","UnpublishAppServiceResponse","NavigationJunction","REGULAR","BIFURCATION","MULTI_CARRIAGEWAY","ROUNDABOUT","TRAVERSABLE_ROUNDABOUT","JUGHANDLE","ALL_WAY_YIELD","TURN_AROUND","Direction","NavigationAction","TURN","EXIT","STAY","MERGE","FERRY","CAR_SHUTTLE_TRAIN","WAYPOINT","NavigationInstruction","setLocationDetails","details","KEY_LOCATION_DETAILS","getLocationDetails","setBearing","bearing","KEY_BEARING","getBearing","setJunctionType","KEY_JUNCTION_TYPE","getJunctionType","setDrivingSide","side","KEY_DRIVING_SIDE","getDrivingSide","setDetails","KEY_DETAILS","getDetails","NavigationServiceData","setOrigin","KEY_ORIGIN","getOrigin","setDestination","KEY_DESTINATION","getDestination","setDestinationETA","KEY_DESTINATION_ETA","getDestinationETA","setInstructions","instructions","KEY_INSTRUCTIONS","getInstructions","setNextInstructionETA","KEY_NEXT_INSTRUCTION_ETA","getNextInstructionETA","setNextInstructionDistance","KEY_NEXT_INSTRUCTION_DISTANCE","getNextInstructionDistance","setNextInstructionDistanceScale","KEY_NEXT_INSTRUCTION_DISTANCE_SCALE","getNextInstructionDistanceScale","setPrompt","KEY_PROMPT","getPrompt","MediaType","MUSIC","PODCAST","AUDIOBOOK","OTHER","MediaServiceData","setMediaType","KEY_MEDIA_TYPE","getMediaType","setMediaTitle","KEY_MEDIA_TITLE","getMediaTitle","setMediaArtist","artist","KEY_MEDIA_ARTIST","getMediaArtist","setMediaAlbum","album","KEY_MEDIA_ALBUM","getMediaAlbum","setPlaylistName","KEY_PLAYLIST_NAME","getPlaylistName","setIsExplicit","explicit","KEY_IS_EXPLICIT","getIsExplicit","setTrackPlaybackProgress","progress","KEY_TRACK_PLAYBACK_PROGRESS","getTrackPlaybackProgress","setTrackPlaybackDuration","KEY_TRACK_PLAYBACK_DURATION","getTrackPlaybackDuration","setQueuePlaybackProgress","KEY_QUEUE_PLAYBACK_PROGRESS","getQueuePlaybackProgress","setQueuePlaybackDuration","KEY_QUEUE_PLAYBACK_DURATION","getQueuePlaybackDuration","setQueueCurrentTrackNumber","KEY_QUEUE_CURRENT_TRACK_NUMBER","getQueueCurrentTrackNumber","setQueueTotalTrackCount","KEY_QUEUE_TOTAL_TRACK_COUNT","getQueueTotalTrackCount","setMediaImage","KEY_MEDIA_IMAGE","getMediaImage","WeatherData","setTemperatureHigh","KEY_TEMPERATURE_HIGH","getTemperatureHigh","setTemperatureLow","KEY_TEMPERATURE_LOW","getTemperatureLow","setApparentTemperature","KEY_APPARENT_TEMPERATURE","getApparentTemperature","setApparentTemperatureHigh","KEY_APPARENT_TEMPERATURE_HIGH","getApparentTemperatureHigh","setApparentTemperatureLow","KEY_APPARENT_TEMPERATURE_LOW","getApparentTemperatureLow","setWeatherSummary","summary","KEY_WEATHER_SUMMARY","getWeatherSummary","KEY_TIME","setHumidity","KEY_HUMIDITY","getHumidity","setCloudCover","cover","KEY_CLOUD_COVER","getCloudCover","setMoonPhase","phase","KEY_MOON_PHASE","getMoonPhase","setWindBearing","KEY_WIND_BEARING","getWindBearing","setWindGust","gust","KEY_WIND_GUST","getWindGust","setWindSpeed","KEY_WIND_SPEED","getWindSpeed","setNearestStormBearing","KEY_NEAREST_STORM_BEARING","getNearestStormBearing","setNearestStormDistance","KEY_NEAREST_STORM_DISTANCE","getNearestStormDistance","setPrecipAccumulation","accumulation","KEY_PRECIP_ACCUMULATION","getPrecipAccumulation","setPrecipIntensity","intensity","KEY_PRECIP_INTENSITY","getPrecipIntensity","setPrecipProbability","probability","KEY_PRECIP_PROBABILITY","getPrecipProbability","setPrecipType","KEY_PRECIP_TYPE","getPrecipType","setVisibility","visibility","KEY_VISIBILITY","getVisibility","setWeatherIcon","KEY_WEATHER_ICON","getWeatherIcon","WeatherAlert","setTitle","KEY_TITLE","getTitle","setSummary","KEY_SUMMARY","getSummary","setExpires","expires","KEY_EXPIRES","getExpires","setRegions","regions","KEY_REGIONS","getRegions","setSeverity","severity","KEY_SEVERITY","getSeverity","setTimeIssued","issued","KEY_TIME_ISSUED","getTimeIssued","WeatherServiceData","setCurrentForecast","forecast","KEY_CURRENT_FORECAST","getCurrentForecast","setMinuteForecast","KEY_MINUTE_FORECAST","getMinuteForecast","setHourlyForecast","KEY_HOURLY_FORECAST","getHourlyForecast","setMultidayForecast","KEY_MULTIDAY_FORECAST","getMultidayForecast","setAlerts","alerts","KEY_ALERTS","getAlerts","AppServiceData","setMediaServiceData","KEY_MEDIA_SERVICE_DATA","getMediaServiceData","setWeatherServiceData","KEY_WEATHER_SERVICE_DATA","getWeatherServiceData","setNavigationServiceData","KEY_NAVIGATION_SERVICE_DATA","getNavigationServiceData","GetAppServiceDataResponse","setServiceData","KEY_SERVICE_DATA","getServiceData","setServiceUri","uri","KEY_SERVICE_URI","getServiceUri","setOriginApp","app","KEY_ORIGIN_APP","getOriginApp","setRequestServiceActive","KEY_REQUEST_SERVICE_ACTIVE","getRequestServiceActive","PerformAppServiceInteractionResponse","setServiceSpecificResult","KEY_SERVICE_SPECIFIC_RESULT","getServiceSpecificResult","setFunctionID","KEY_FUNCTION_ID","getFunctionID","CancelInteractionResponse","CloseApplicationResponse","SystemContext","SYSCTXT_MAIN","SYSCTXT_VRSESSION","SYSCTXT_MENU","SYSCTXT_HMI_OBSCURED","SYSCTXT_ALERT","RpcNotification","AudioStreamingState","AUDIBLE","ATTENUATED","NOT_AUDIBLE","HMILevel","HMI_FULL","HMI_LIMITED","HMI_BACKGROUND","HMI_NONE","VideoStreamingState","STREAMABLE","NOT_STREAMABLE","setHmiLevel","KEY_HMI_LEVEL","getHmiLevel","setAudioStreamingState","KEY_AUDIO_STREAMING_STATE","getAudioStreamingState","setSystemContext","KEY_SYSTEM_CONTEXT","getSystemContext","setVideoStreamingState","KEY_VIDEO_STREAMING_STATE","getVideoStreamingState","AppInterfaceUnregisteredReason","IGNITION_OFF","BLUETOOTH_OFF","USB_DISCONNECTED","REQUEST_WHILE_IN_NONE_HMI_LEVEL","TOO_MANY_REQUESTS","DRIVER_DISTRACTION_VIOLATION","LANGUAGE_CHANGE","MASTER_RESET","FACTORY_DEFAULTS","APP_UNAUTHORIZED","PROTOCOL_VIOLATION","UNSUPPORTED_HMI_RESOURCE","setReason","KEY_REASON","getReason","ButtonEventMode","BUTTONUP","BUTTONDOWN","setButtonEventMode","KEY_BUTTON_EVENT_MODE","getButtonEventMode","setCustomButtonID","KEY_CUSTOM_BUTTON_ID","getCustomButtonID","TBTState","ROUTE_UPDATE_REQUEST","ROUTE_ACCEPTED","ROUTE_REFUSED","ROUTE_CANCELLED","ETA_REQUEST","NEXT_TURN_REQUEST","ROUTE_STATUS_REQUEST","ROUTE_SUMMARY_REQUEST","TRIP_STATUS_REQUEST","ROUTE_UPDATE_REQUEST_TIMEOUT","DriverDistractionState","DD_ON","DD_OFF","setLockScreenDismissalEnabled","KEY_LOCK_SCREEN_DISMISSAL_ENABLED","getLockScreenDismissalEnabled","setLockScreenDismissalWarning","warning","KEY_LOCK_SCREEN_DISMISSAL_WARNING","getLockScreenDismissalWarning","HMIPermissions","setUserDisallowed","disallowed","KEY_USER_DISALLOWED","getUserDisallowed","ParameterPermissions","PermissionItem","setRpcName","KEY_RPC_NAME","getRpcName","setHmiPermissions","permissions","KEY_HMI_PERMISSIONS","getHmiPermissions","setParameterPermissions","KEY_PARAMETER_PERMISSIONS","getParameterPermissions","setRequireEncryption","KEY_REQUIRE_ENCRYPTION","getRequireEncryption","setPermissionItem","KEY_PERMISSION_ITEM","getPermissionItem","KeyboardEvent","KEYPRESS","ENTRY_SUBMITTED","ENTRY_VOICE","ENTRY_CANCELLED","ENTRY_ABORTED","setEvent","KEY_EVENT","getEvent","TouchCoord","TouchEvent","setTs","ts","KEY_TS","getTs","setC","KEY_C","getC","TouchType","BEGIN","MOVE","END","CANCEL","setUrl","url","KEY_URL","getUrl","setAllocatedModules","KEY_ALLOCATED_MODULES","getAllocatedModules","setFreeModules","KEY_FREE_MODULES","getFreeModules","EncodedSyncPDataResponse","setURL","getURL","RpcCreator","construct","rpcName","jsonData","SdlProtocolBase","baseTransportConfig","sdlProtocolListener","_baseTransportConfig","_sdlProtocolListener","_transportManager","_reset","_createTransportListener","_protocolVersion","_headerSize","V1_HEADER_SIZE","_serviceStatus","_mtus","V1_V2_MTU_SIZE","_hashID","_messageFrameAssemblers","setTransportManager","manager","startService","_transportListener","_handleTransportConnected","_handlePacketReceived","protocolVersion","MAX_PROTOCOL_VERSION","sendPacket","videoStreamingParameters","desiredResolution","desiredFormat","getFormat","getMtu","retVal","isConnected","getProtocolVersion","_setVersion","V2_HEADER_SIZE","V3_V4_MTU_SIZE","_getNextMessageID","sendRpc","_handleControlPacket","messageFrameAssembler","_getMessageFrameAssembler","_handleOnMessageAssembled","_handleRPCPacket","_handleProtocolHeartbeat","_handleProtocolHeartbeatACK","_handleStartServiceACK","_handleStartServiceNAK","_handleEndServiceACK","_handleEndService","_handleEndServiceNAK","heartbeat","mtuTag","NAV","acceptedResolution","acceptedFormat","agreedVideoParams","setFormat","_handleServiceEnded","rejectedTag","rejectedParams","endService","TransportType","WEBSOCKET_CLIENT","WEBSOCKET_SERVER","CUSTOM","SdlPsm","reset","_state","START_STATE","_controlFrameInfo","_dumpSize","_dataLength","getFormedPacket","FINISHED_STATE","handleByte","_transitionOnInput","ERROR_STATE","rawByte","VERSION_MASK","ENCRYPTION_MASK","FRAME_TYPE_MASK","SERVICE_TYPE_STATE","CONTROL_FRAME_INFO_STATE","SESSION_ID_STATE","DATA_SIZE_1_STATE","DATA_SIZE_2_STATE","DATA_SIZE_3_STATE","DATA_SIZE_4_STATE","DATA_PUMP_STATE","FIRST_FRAME_DATA_SIZE","MESSAGE_1_STATE","MESSAGE_2_STATE","MESSAGE_3_STATE","MESSAGE_4_STATE","TransportBase","transportCallback","_sdlPsm","_transportCallback","stop","setTransportCallback","WebSocketClient","config","_queue","_isRunning","_wsUrl","getHost","getPort","_ws","_init","WebSocket","onopen","onConnectionEstablished","onerror","onmessage","_handleIncoming","onclose","onConnectionTerminated","close","packet","send","_multiByteHandler","msgData","Response","arrayBuffer","then","_handleByte","isFinished","TransportCallback","_onConnectionEstablished","_onConnectionTerminated","setOnConnectionEstablished","setOnConnectionTerminated","TransportManagerBase","transportListener","_transport","_isConnected","getTransportType","getTransport","transportType","require$$1","WebSocketServer","_connectionLostInterval","client","getClient","connectionLostTimeout","getConnectionLostTimeout","_handleMessage","_stopConnectionLostInterval","errorEvent","isAlive","setInterval","terminate","ping","readyState","clearInterval","stateProgress","messageIndex","require$$2","TransportManager","SdlProtocol","ServiceListenerMap","_listeners","addListener","serviceListener","removeListener","listenerArray","removed","sendEventServiceStarted","session","sendEventServiceEnded","sendEventServiceError","onServiceError","DEFAULT_PROTOCOL","DEFAULT_CODEC","DEFAULT_WIDTH","DEFAULT_HEIGHT","DEFAULT_DENSITY","DEFAULT_FRAMERATE","DEFAULT_BITRATE","DEFAULT_INTERVAL","DEFAULT_SCALE","VideoStreamingParameters","displayDensity","frameRate","interval","_displayDensity","_frameRate","_bitrate","_interval","_resolution","_format","update","setDisplayDensity","getDisplayDensity","setFrameRate","getFrameRate","setBitrate","getBitrate","getInterval","SdlSession","sdlSessionListener","_sessionHashId","_sdlSessionListener","_serviceListeners","_setupSdlProtocolListener","_sdlProtocol","getCurrentTransportType","getIsConnected","getSessionHashId","addServiceListener","sdlServiceListener","removeServiceListener","getServiceListeners","setDesiredVideoParams","_desiredVideoParams","SdlSessionListener","correlationI","ArrayTools","arrayRemove","ele","LifecycleManager","appConfig","lifecycleListener","_appConfig","_lifecycleListener","_sdlSession","_createSessionListener","_currentHMIStatus","_firstTimeFull","_responseListeners","_maxCorrelationId","_rpcListeners","sessionListener","sendRpcMessage","_createRegisterAppInterface","_handleRpc","functionID","resolve","_setupInternalRpcListeners","addRpcListener","rpcListener","removeRpcListener","getRegisterAppInterfaceResponse","_registerAppInterfaceResponse","registerAppInterface","MAX_RPC_VERSION","REGISTER_APP_INTERFACE_CORRELATION_ID","_rpcListener","_processRaiResponse","shouldInit","registerAppInterfaceResponse","msgVersion","UNREGISTER_APP_INTERFACE_CORRELATION_ID","AppServiceType","WEATHER","MaintenanceModeStatus","MMS_NORMAL","MMS_NEAR","MMS_ACTIVE","MMS_FEATURE_NOT_PRESENT","PermissionStatus","PS_ALLOWED","PS_DISALLOWED","PS_USER_DISALLOWED","PS_USER_CONSENT_PENDING","PredefinedLayout","NON_MEDIA","ONSCREEN_PRESETS","NAV_FULLSCREEN_MAP","NAV_LIST","NAV_KEYBOARD","GRAPHIC_WITH_TEXT","TEXT_WITH_GRAPHIC","TILES_ONLY","TEXTBUTTONS_ONLY","GRAPHIC_WITH_TILES","TILES_WITH_GRAPHIC","GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS","TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC","GRAPHIC_WITH_TEXTBUTTONS","TEXTBUTTONS_WITH_GRAPHIC","LARGE_GRAPHIC_WITH_SOFTBUTTONS","DOUBLE_GRAPHIC_WITH_SOFTBUTTONS","LARGE_GRAPHIC_ONLY","PredefinedWindows","DEFAULT_WINDOW","PRIMARY_WIDGET","TimerMode","UP","DOWN","VehicleDataActiveStatus","VDAS_INACTIVE_NOT_CONFIRMED","VDAS_INACTIVE_CONFIRMED","VDAS_ACTIVE_NOT_CONFIRMED","VDAS_ACTIVE_CONFIRMED","VDAS_FAULT","messageType","request","response","notification","SdlServiceListener","_onServiceError","setOnServiceError","CustomTransport","onSendPacket","onByteBufferReceived","sdlPsm","TransportConfigBase","_transportType","CustomTransportConfig","customTransport","_customTransport","SslConfig","pemCertificate","privateKey","password","_pemCertificate","_privateKey","_password","getPemCertificate","getPrivateKey","getPassword","WebSocketClientConfig","host","port","_host","_port","TransportRecord","_address","WebSocketServerConfig","_client","_connectionLostTimeout","SDL","lifecycle","enums","rpc","messages","structs","video","transport"],"mappings":"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EACuJ,GADvJ,EAC4J,GAD5J,EACiK,EADjK,EACqK,GADrK,EAC0K,CAD1K,EAC6K,CAD7K,EACgL,CADhL,EACmL,GADnL,EACwL,GADxL,EAC6L,GAD7L,EACkM,EADlM,EACsM,GADtM,EAC2M,CAD3M,EAC8M,CAD9M,EACiN,CADjN,EACoN,GADpN,EACyN,GADzN,EAC8N,GAD9N,EACmO,EADnO,EACuO,GADvO,EAC4O,CAD5O,EAC+O,CAD/O,EACkP,CADlP,EACqP,GADrP,EAC0P,GAD1P,EAC+P,GAD/P,EACoQ,EADpQ,EACwQ,GADxQ,EAC6Q,GAD7Q,EACkR,GADlR,EACuR,GADvR,EAC4R,CAD5R,EAC+R,CAD/R,EACkS,EADlS,EACsS,GADtS,EAC2S,CAD3S,EAC8S,CAD9S,EACiT,CADjT,EACoT,CADpT,EACuT,EADvT,EAC2T,CAD3T,EAC8T,EAD9T,EACkU,EADlU,EACsU,CADtU,EACyU,CADzU,EAC4U,GAD5U,EACiV,EADjV,EACqV,CADrV,EACwV,GADxV,EAC6V,EAD7V,EACiW,CADjW,EACoW,GADpW,EACyW,EADzW,EAC6W,EAD7W,EACiX,GADjX,EACsX,GADtX,EAC2X,EAD3X,EAC+X,CAD/X,EACkY,GADlY,EACuY,EADvY,EAC2Y,CAD3Y,EAC8Y,GAD9Y,EACmZ,EADnZ,EACuZ,EADvZ,EAC2Z,GAD3Z,EACga,GADha,EACqa,GADra,EAC0a,EAD1a,EAC8a,CAD9a,EACib,EADjb,EACqb,EADrb,EACyb,GADzb,EAC8b,GAD9b,EACmc,EADnc,EACuc,CADvc,EAC0c,EAD1c,EAC8c,CAD9c,EACid,GADjd,EACsd,EADtd,EAC0d,EAD1d,EAC8d,CAD9d,EACie,CADje,EACoe,GADpe,EACye,EADze,EAC6e,CAD7e,EACgf,GADhf,EACqf,EADrf,EACyf,CADzf,EAC4f,GAD5f,EACigB,EADjgB,EACqgB,EADrgB,EACygB,GADzgB,EAC8gB,GAD9gB,EACmhB,EADnhB,EACuhB,CADvhB,EAC0hB,GAD1hB,EAC+hB,EAD/hB,EACmiB,CADniB,EACsiB,GADtiB,EAC2iB,EAD3iB,EAC+iB,EAD/iB,EACmjB,GADnjB,EACwjB,GADxjB,EAC6jB,GAD7jB,EACkkB,EADlkB,EACskB,CADtkB,EACykB,EADzkB,EAC6kB,EAD7kB,EACilB,GADjlB,EACslB,GADtlB,EAC2lB,EAD3lB,EAC+lB,CAD/lB,EACkmB,EADlmB,EACsmB,CADtmB,EACymB,GADzmB,EAC8mB,EAD9mB,EACknB,EADlnB,EACsnB,CADtnB,EACynB,CADznB,EAC4nB,GAD5nB,EACioB,EADjoB,EACqoB,CADroB,EACwoB,GADxoB,EAC6oB,EAD7oB,EACipB,CADjpB,EACopB,GADppB,EACypB,EADzpB,EAC6pB,EAD7pB,EACiqB,GADjqB,EACsqB,GADtqB,EAC2qB,EAD3qB,EAC+qB,CAD/qB,EACkrB,GADlrB,EACurB,EADvrB,EAC2rB,CAD3rB,EAC8rB,GAD9rB,EACmsB,EADnsB,EACusB,EADvsB,EAC2sB,GAD3sB,EACgtB,GADhtB,EACqtB,GADrtB,EAC0tB,EAD1tB,EAC8tB,CAD9tB,EACiuB,EADjuB,EACquB,EADruB,EACyuB,GADzuB,EAC8uB,GAD9uB,EACmvB,EADnvB,EACuvB,CADvvB,EAC0vB,EAD1vB,EAC8vB,CAD9vB,EACiwB,GADjwB,EACswB,EADtwB,EAC0wB,EAD1wB,EAC8wB,CAD9wB,EACixB,CADjxB,EACoxB,GADpxB,EACyxB,EADzxB,EAC6xB,CAD7xB,EACgyB,GADhyB,EACqyB,EADryB,EACyyB,CADzyB,EAC4yB,GAD5yB,EACizB,EADjzB,EACqzB,EADrzB,EACyzB,GADzzB,EAC8zB,GAD9zB,EACm0B,EADn0B,EACu0B,CADv0B,EAC00B,GAD10B,EAC+0B,EAD/0B,EACm1B,CADn1B,EACs1B,GADt1B,EAC21B,EAD31B,EAC+1B,EAD/1B,EACm2B,GADn2B,EACw2B,GADx2B,EAC62B,GAD72B,EACk3B,EADl3B,EACs3B,CADt3B,EACy3B,EADz3B,EAC63B,EAD73B,EACi4B,GADj4B,EACs4B,GADt4B,EA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"} diff --git a/lib/rpc_spec b/lib/rpc_spec new file mode 160000 index 00000000..8bda2918 --- /dev/null +++ b/lib/rpc_spec @@ -0,0 +1 @@ +Subproject commit 8bda29189ca7f6e81d285d6aab9768cd83b93a14 diff --git a/package-lock.json b/package-lock.json index 53d6a4eb..e56ef6d1 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1578,6 +1578,12 @@ "babel-helper-is-void-0": "^0.4.3" } }, + "babel-plugin-transform-async-to-promises": { + "version": "0.8.15", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-async-to-promises/-/babel-plugin-transform-async-to-promises-0.8.15.tgz", + "integrity": "sha512-fDXP68ZqcinZO2WCiimCL9zhGjGXOnn3D33zvbh+yheZ/qOrNVVDDIBtAaM3Faz8TRvQzHiRKsu3hfrBAhEncQ==", + "dev": true + }, "babel-plugin-transform-inline-consecutive-adds": { "version": "0.4.3", "resolved": "https://registry.npmjs.org/babel-plugin-transform-inline-consecutive-adds/-/babel-plugin-transform-inline-consecutive-adds-0.4.3.tgz", diff --git a/package.json b/package.json index 7ec875ad..07b98342 100644 --- a/package.json +++ b/package.json @@ -36,6 +36,7 @@ "devDependencies": { "@babel/preset-env": "^7.7.1", "babel-minify-webpack-plugin": "^0.3.1", + "babel-plugin-transform-async-to-promises": "^0.8.15", "bson": "^4.0.2", "chai": "^4.2.0", "eslint": "^6.6.0", diff --git a/rollup.config.js b/rollup.config.js index 810f0e1b..48a71540 100644 --- a/rollup.config.js +++ b/rollup.config.js @@ -22,6 +22,7 @@ export default [{ // Vanilla JS source commonjs(), babel({ exclude: 'node_modules/**', // only transpile our source code + plugins: ["babel-plugin-transform-async-to-promises"] // convert async/await syntax }), uglify(), ], @@ -42,6 +43,7 @@ export default [{ // Vanilla JS source commonjs(), babel({ exclude: 'node_modules/**', // only transpile our source code + plugins: ["babel-plugin-transform-async-to-promises"] // convert async/await syntax }), ], external: ['ws', 'https']