Skill submitted for verification

7 years ago · bdb62655a5
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 source.zip
 node_modules
--- a/src/package.json
+++ b/src/package.json
@@ -4,8 +4,7 @@
  "description": "Provides a random hero",
  "main": "index.js",
  "dependencies": {
    "alexa-sdk": "^1.0.6",
    "xmlhttprequest": "^1.00"
    "alexa-sdk": "^1.0.6"
  },
  "author": "binhonglee",
  "license": "MIT",
--- a/speechAssets/IntentSchema.json
+++ b/speechAssets/IntentSchema.json
@@ -3,6 +3,15 @@
    {
      "intent": "RequestIntent"
    },
    {
      "intent": "RequestSpecificIntent",
      "slots": [
        {
          "name": "AttackType",
          "type": "AMAZON.US_STATE"
        }
      ]
    },
    {
      "intent": "StopIntent"
    }
--- a/speechAssets/Utterances.txt
+++ b/speechAssets/Utterances.txt
@@ -1,3 +1,6 @@
 RequestIntent give me random hero
 RequestIntent another hero
 RequestIntent random any hero
 RequestIntent random any other hero
 RequestSpecificIntent random {AttackType}
 RequestSpecificIntent random another {AttackType}
 RequestSpecificIntent random {AttackType} again
 StopIntent stop
--- a/src/index.js
+++ b/src/index.js
@@ -1,8 +1,6 @@
 'use strict'

 const Alexa = require('alexa-sdk')
 var https = require('https')
 let response = ''

 exports.handler = function (event, context, callback) {
  var alexa = Alexa.handler(event, context)
@@ -22,31 +20,24 @@ var handlers = {

  // RequestIntent handler
  'RequestIntent': function () {
    var info = {
      host: 'api.opendota.com/api/heroes',
      port: 443,
      path: '/api/heroes',
      method: 'GET'
    }

    var req = https.request(info, res => {
      res.setEncoding('utf8')
      var returnData = ''
    var speechOutput = random(0)

      res.on('data', chunk => {
        returnData = returnData + chunk
      })

      res.on('end', () => {
        response = JSON.parse(returnData)
      })
    })
    // Emit the message
    this.emit(':ask', speechOutput)
  },

    req.end()
  'RequestSpecificIntent': function () {
    var attackType = this.event.request.intent.slots.AttackType
    let speechOutput = ''

    var speechOutput = 'Output is :' + response[getRandomInt() - 1] + '?'
    if (attackType.value === 'melee') {
      speechOutput = random(1)
    } else if (attackType.value === 'ranged') {
      speechOutput = random(2)
    } else {
      speechOutput = random(0)
    }

    // Emit the message
    this.emit(':ask', speechOutput)
  },

@@ -57,6 +48,137 @@ var handlers = {
  }
 }

 function getRandomInt () {
  return Math.random() * (response.length)
 function random (num) {
  if (num === 1) {
    return melee[Math.floor(Math.random() * melee.length)]
  } else if (num === 2) {
    return ranged[Math.floor(Math.random() * ranged.length)]
  } else {
    var result = Math.floor(Math.random() * (melee.length + ranged.length))

    if (result < melee.length) {
      return melee[result]
    } else {
      return ranged[result - melee.length]
    }
  }
 }

 var melee = [
  'Anti-Mage',
  'Axe',
  'Bloodseeker',
  'Earthshaker',
  'Juggernaut',
  'Phantom Lancer',
  'Pudge',
  'Sand King',
  'Sven',
  'Tiny',
  'Kunkka',
  'Slardar',
  'Tidehunter',
  'Riki',
  'Beastmaster',
  'Faceless Void',
  'Wraith King',
  'Phantom Assassin',
  'Dragon Knight',
  'Clockwerk',
  'Lifestealer',
  'Dark Seer',
  'Omniknight',
  'Night Stalker',
  'Broodmother',
  'Bounty Hunter',
  'Spectre',
  'Doom',
  'Ursa',
  'Spirit Breaker',
  'Alchemist',
  'Lycan',
  'Brewmaster',
  'Chaos Knight',
  'Meepo',
  'Treant Protector',
  'Ogre Magi',
  'Undying',
  'Nyx Assassin',
  'Naga Siren',
  'Slark',
  'Centaur Warrunner',
  'Magnus',
  'Timbersaw',
  'Bristleback',
  'Tusk',
  'Abaddon',
  'Elder Titan',
  'Legion Commander',
  'Ember Spirit',
  'Earth Spirit',
  'Underlord',
  'Terrorblade',
  'Monkey King'
 ]

 var ranged = [
  'Bane',
  'Crystal Maiden',
  'Drow Ranger',
  'Mirana',
  'Morphling',
  'Shadow Fiend',
  'Puck',
  'Razor',
  'Storm Spirit',
  'Vengeful Spirit',
  'Windranger',
  'Zeus',
  'Lina',
  'Lion',
  'Shadow Shaman',
  'Witch Doctor',
  'Lich',
  'Enigma',
  'Tinker',
  'Sniper',
  'Necrophos',
  'Warlock',
  'Queen of Pain',
  'Venomancer',
  'Death Prophet',
  'Pugna',
  'Templar Assassin',
  'Viper',
  'Luna',
  'Dazzle',
  'Leshrac',
  'Nature\'s Prophet',
  'Clinkz',
  'Enchantress',
  'Huskar',
  'Weaver',
  'Jakiro',
  'Batrider',
  'Chen',
  'Ancient Apparition',
  'Gyrocopter',
  'Invoker',
  'Silencer',
  'Outworld Devourer',
  'Shadow Demon',
  'Lone Druid',
  'Rubick',
  'Disruptor',
  'Keeper of the Light',
  'Io',
  'Visage',
  'Medusa',
  'Troll Warlord',
  'Skywrath Mage',
  'Techies',
  'Phoenix',
  'Oracle',
  'Winter Wyvern',
  'Arc Warden'
 ]
--- a/src/node_modules/.bin/uuid
+++ b/src/node_modules/.bin/uuid
@@ -1 +0,0 @@
 ../uuid/bin/uuid
--- a/src/node_modules/alexa-sdk/.npmignore
+++ b/src/node_modules/alexa-sdk/.npmignore
@@ -1 +0,0 @@
 node_modules
--- a/src/node_modules/alexa-sdk/LICENSE.txt
+++ b/src/node_modules/alexa-sdk/LICENSE.txt
@@ -1,202 +0,0 @@

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
--- a/src/node_modules/alexa-sdk/NOTICE.txt
+++ b/src/node_modules/alexa-sdk/NOTICE.txt
@@ -1,2 +0,0 @@
 Alexa SDK for JavaScript
 Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
--- a/src/node_modules/alexa-sdk/Readme.md
+++ b/src/node_modules/alexa-sdk/Readme.md
@@ -1,543 +0,0 @@
 # Alexa Skills Kit SDK for Node.js

 Today we're happy to announce the new [alexa-sdk](https://github.com/alexa/alexa-skills-kit-sdk-for-nodejs) for Node.js to help you build skills faster and with less complexity.

 Creating an Alexa skill using the [Alexa Skills Kit](http://developer.amazon.com/ask), [Node.js](https://nodejs.org/en/) and [AWS Lambda](https://aws.amazon.com/lambda/) has become one of the most popular ways we see skills created today. The event-driven, non-blocking I/O model of Node.js is well suited for an Alexa skill and Node.js is one of the largest ecosystems of open source libraries in the world. Plus, AWS Lambda is free for the first one million calls per month, which is enough for most developers. Also, when using AWS Lambda you don't need to manage any SSL certificates since the Alexa Skills Kit is a trusted trigger.

 While setting up an Alexa skill using AWS Lambda, Node.js and the Alexa Skills Kit has been a simple process, the actual amount of code you have had to write has not. We have seen a large amount of time spent in Alexa skills on handling session attributes, skill state persistence, response building and behavior modeling. With that in mind the Alexa team set out to build an Alexa Skills Kit SDK specifically for Node.js that will help you avoid common hang-ups and focus on your skill's logic instead of boilerplate code.

 ### Enabling Faster Alexa Skill Development with the Alexa Skills Kit SDK for Node.js (alexa-sdk)

 With the new alexa-sdk, our goal is to help you build skills faster while allowing you to avoid unneeded complexity. Today, we are launching the SDK with the following capabilities:

 - Hosted as an NPM package allowing simple deployment to any Node.js environment
 - Ability to build Alexa responses using built-in events
 - Helper events for new sessions and unhandled events that can act as a 'catch-all' events
 - Helper functions to build state-machine based Intent handling
  - This makes it possible to define different event handlers based on the current state of the skill
 - Simple configuration to enable attribute persistence with DynamoDB
 - All speech output is automatically wrapped as SSML
 - Lambda event and context objects are fully available via `this.event` and `this.context`
 - Ability to override built-in functions giving you more flexibility on how you manage state or build responses. For example, saving state attributes to AWS S3.

 ### Installing and Working with the Alexa Skills Kit SDK for Node.js (alexa-sdk)

 The alexa-sdk is immediately available on [github](https://github.com/alexa/alexa-skills-kit-sdk-for-nodejs) and can be deployed as a node package using the following command from within your Node.js environment:
 ```bash
 npm install --save alexa-sdk
 ```

 In order to start using the alexa-sdk first import the library. To do this within your own project simply create a file named index.js and add the following to it:
 ```javascript
 var Alexa = require('alexa-sdk');

 exports.handler = function(event, context, callback){
    var alexa = Alexa.handler(event, context, callback);
 };
 ```
 This will import alexa-sdk and set up an `Alexa` object for us to work with. Next, we need to handle the intents for our skill. Alexa-sdk makes it simple to have a function fire an Intent. For example, to create a handler for 'HelloWorldIntent' we simply add the following:
 ```javascript
 var handlers = {

    'HelloWorldIntent': function () {
        this.emit(':tell', 'Hello World!');
    }

 };
 ```
 Notice the new syntax above for ':tell'? Alexa-sdk follows a tell/ask response methodology for generating your [outputSpeech response objects](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/alexa-skills-kit-interface-reference#Response%20Format). To ask the user for information we would instead use an `:ask` action. The difference between `:ask` and `:tell` is that after a `:tell` action, the session is ended without waiting for the user to provide more input.
 ```javascript
 this.emit(':ask', 'What would you like to do?', 'Please say that again?');
 ```
 In fact, many of the responses follow this same syntax! Here are some additional examples for common skill responses:
 ```javascript
 var speechOutput = 'Hello world!';
 var repromptSpeech = 'Hello again!';

 this.emit(':tell', speechOutput);

 this.emit(':ask', speechOutput, repromptSpeech);

 var cardTitle = 'Hello World Card';
 var cardContent = 'This text will be displayed in the companion app card.';

 var imageObj = {
    smallImageUrl: 'https://imgs.xkcd.com/comics/standards.png',
    largeImageUrl: 'https://imgs.xkcd.com/comics/standards.png'
 };

 var permissionArray = ['read::alexa:device:all:address'];

 var updatedIntent = this.event.request.intent;

 var slotToElicit = "Slot to elicit";

 var slotToConfirm = "Slot to confirm";

 this.emit(':askWithCard', speechOutput, repromptSpeech, cardTitle, cardContent, imageObj);

 this.emit(':tellWithCard', speechOutput, cardTitle, cardContent, imageObj);

 this.emit(':tellWithLinkAccountCard', speechOutput);

 this.emit(':askWithLinkAccountCard', speechOutput);

 this.emit(':tellWithPermissionCard', speechOutput, permissionArray);

 this.emit(':delegate', updatedIntent);

 this.emit(':elicitSlot', slotToElicit, speechOutput, repromptSpeech, updatedIntent);

 this.emit(':elicitSlotWithCard', slotToElicit, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj);

 this.emit(':confirmSlot', slotToConfirm, speechOutput, repromptSpeech, updatedIntent);

 this.emit(':confirmSlotWithCard', slotToConfirm, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj);

 this.emit(':confirmIntent', speechOutput, repromptSpeech, updatedIntent);

 this.emit(':confirmIntentWithCard', speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj);

 this.emit(':responseReady'); // Called after the response is built but before it is returned to the Alexa service. Calls :saveState. Can be overridden.

 this.emit(':saveState', false); // Handles saving the contents of this.attributes and the current handler state to DynamoDB and then sends the previously built response to the Alexa service. Override if you wish to use a different persistence provider. The second attribute is optional and can be set to 'true' to force saving.

 this.emit(':saveStateError'); // Called if there is an error while saving state. Override to handle any errors yourself.
 ```
 Once we have set up our event handlers we need to register them using the registerHandlers function of the alexa object we just created.
 ```javascript
  exports.handler = function(event, context, callback) {
      var alexa = Alexa.handler(event, context, callback);
      alexa.registerHandlers(handlers);
  };
 ```
 You can also register multiple handler objects at once:
 ```javascript
  alexa.registerHandlers(handlers, handlers2, handlers3, ...);
 ```
 The handlers you define can call each other, making it possible to ensure your responses are uniform.  Here is an example where our LaunchRequest and IntentRequest (of HelloWorldIntent) both return the same 'Hello World' message.
 ```javascript
 var handlers = {
    'LaunchRequest': function () {
        this.emit('HelloWorldIntent');
    },

    'HelloWorldIntent': function () {
        this.emit(':tell', 'Hello World!');
    }
 };
 ```
 Once you are done registering all of your intent handler functions, you simply use the execute function from the alexa object to run your skill's logic. The final line would look like this:
 ```javascript
 exports.handler = function(event, context, callback) {
    var alexa = Alexa.handler(event, context, callback);
    alexa.registerHandlers(handlers);
    alexa.execute();
 };
 ```
 You can download a full working sample off github. We have also updated the following Node.js sample skills to work with the alexa-sdk: [Fact](https://github.com/alexa/skill-sample-nodejs-fact), [HelloWorld](https://github.com/alexa/skill-sample-nodejs-hello-world), [HighLow](https://github.com/alexa/skill-sample-nodejs-highlowgame), [HowTo](https://github.com/alexa/skill-sample-nodejs-howto) and [Trivia](https://github.com/alexa/skill-sample-nodejs-trivia).

 Note: for specifications regarding the ```imgObj``` please see [here](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/providing-home-cards-for-the-amazon-alexa-app).

 ### Making Skill State Management Simpler

 Alexa-sdk will route incoming intents to the correct function handler based on state. State is stored as a string in your session attributes indicating the current state of the skill. You can emulate the built-in intent routing by appending the state string to the intent name when defining your intent handlers, but alexa-sdk helps do that for you.

 For example, let's create a simple number-guessing game with 'start' and 'guess' states based on our previous example of handling a `NewSession` event.
 ```javascript
 var states = {
    GUESSMODE: '_GUESSMODE', // User is trying to guess the number.
    STARTMODE: '_STARTMODE'  // Prompt the user to start or restart the game.
 };

 var newSessionHandlers = {

     // This will short-cut any incoming intent or launch requests and route them to this handler.
    'NewSession': function() {
        if(Object.keys(this.attributes).length === 0) { // Check if it's the first time the skill has been invoked
            this.attributes['endedSessionCount'] = 0;
            this.attributes['gamesPlayed'] = 0;
        }
        this.handler.state = states.STARTMODE;
        this.emit(':ask', 'Welcome to High Low guessing game. You have played '
            + this.attributes['gamesPlayed'].toString() + ' times. Would you like to play?',
            'Say yes to start the game or no to quit.');
    }
 };
 ```
 Notice that when a new session is created we simply set the state of our skill into `STARTMODE` using this.handler.state. The skills state will automatically be persisted in your skill's session attributes, and will be optionally persisted across sessions if you set a DynamoDB table.

 It is also important point out that `NewSession` is a great catch-all behavior and a good entry point but it is not required. `NewSession` will only be invoked if a handler with that name is defined. Each state you define can have its own `NewSession` handler which will be invoked if you are using the built-in persistence. In the above example we could define different `NewSession` behavior for both `states.STARTMODE` and `states.GUESSMODE` giving us added flexibility.

 In order to define intents that will respond to the different states of our skill, we need to use the `Alexa.CreateStateHandler` function. Any intent handlers defined here will only work when the skill is in a specific state, giving us even greater flexibility!

 For example, if we are in the `GUESSMODE` state we defined above we want to handle a user responding to a question. This can be done using StateHandlers like this:
 ```javascript
 var guessModeHandlers = Alexa.CreateStateHandler(states.GUESSMODE, {

    'NewSession': function () {
        this.handler.state = '';
        this.emitWithState('NewSession'); // Equivalent to the Start Mode NewSession handler
    },

    'NumberGuessIntent': function() {
        var guessNum = parseInt(this.event.request.intent.slots.number.value);
        var targetNum = this.attributes['guessNumber'];

        console.log('user guessed: ' + guessNum);

        if(guessNum > targetNum){
            this.emit('TooHigh', guessNum);
        } else if( guessNum < targetNum){
            this.emit('TooLow', guessNum);
        } else if (guessNum === targetNum){
            // With a callback, use the arrow function to preserve the correct 'this' context
            this.emit('JustRight', () => {
                this.emit(':ask', guessNum.toString() + 'is correct! Would you like to play a new game?',
                'Say yes to start a new game, or no to end the game.');
            });
        } else {
            this.emit('NotANum');
        }
    },

    'AMAZON.HelpIntent': function() {
        this.emit(':ask', 'I am thinking of a number between zero and one hundred, try to guess and I will tell you' +
            ' if it is higher or lower.', 'Try saying a number.');
    },

    'SessionEndedRequest': function () {
        console.log('session ended!');
        this.attributes['endedSessionCount'] += 1;
        this.emit(':saveState', true); // Be sure to call :saveState to persist your session attributes in DynamoDB
    },

    'Unhandled': function() {
        this.emit(':ask', 'Sorry, I didn\'t get that. Try saying a number.', 'Try saying a number.');
    }

 });
 ```
 On the flip side, if I am in `STARTMODE` I can define my `StateHandlers` to be the following:

 ```javascript
 var startGameHandlers = Alexa.CreateStateHandler(states.STARTMODE, {

    'NewSession': function () {
        this.emit('NewSession'); // Uses the handler in newSessionHandlers
    },

    'AMAZON.HelpIntent': function() {
        var message = 'I will think of a number between zero and one hundred, try to guess and I will tell you if it' +
            ' is higher or lower. Do you want to start the game?';
        this.emit(':ask', message, message);
    },

    'AMAZON.YesIntent': function() {
        this.attributes['guessNumber'] = Math.floor(Math.random() * 100);
        this.handler.state = states.GUESSMODE;
        this.emit(':ask', 'Great! ' + 'Try saying a number to start the game.', 'Try saying a number.');
    },

    'AMAZON.NoIntent': function() {
        this.emit(':tell', 'Ok, see you next time!');
    },

    'SessionEndedRequest': function () {
        console.log('session ended!');
        this.attributes['endedSessionCount'] += 1;
        this.emit(':saveState', true);
    },

    'Unhandled': function() {
        var message = 'Say yes to continue, or no to end the game.';
        this.emit(':ask', message, message);
    }
 });
 ```
 Take a look at how `AMAZON.YesIntent` and `AMAZON.NoIntent` are not defined in the `guessModeHandlers` object, since it doesn't make sense for a 'yes' or 'no' response in this state. Those intents will be caught by the `Unhandled` handler.

 Also, notice the different behavior for `NewSession` and `Unhandled` across both states? In this game, we 'reset' the state by calling a `NewSession` handler defined in the `newSessionHandlers` object. You can also skip defining it and alexa-sdk will call the intent handler for the current state. Just remember to register your State Handlers before you call `alexa.execute()` or they will not be found.

 Your attributes will be automatically saved when you end the session, but if the user ends the session you have to emit the `:saveState` event (`this.emit(':saveState', true)`) to force a save. You should do this in your `SessionEndedRequest` handler which is called when the user ends the session by saying 'quit' or timing out. Take a look at the example above.

 We have wrapped up the above example into a high/low number guessing game skill you can [download here](https://github.com/alexa/skill-sample-nodejs-highlowgame).

 ### Persisting Skill Attributes through DynamoDB

 Many of you would like to persist your session attribute values into storage for further use. Alexa-sdk integrates directly with [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) (a NoSQL database service) to enable you to do this with a single line of code.

 Simply set the name of the DynamoDB table on your alexa object before you call alexa.execute.
 ```javascript
 exports.handler = function (event, context, callback) {
    var alexa = Alexa.handler(event, context, callback);
    alexa.appId = appId;
    alexa.dynamoDBTableName = 'YourTableName'; // That's it!
    alexa.registerHandlers(State1Handlers, State2Handlers);
    alexa.execute();
 };
 ```

 Then later on to set a value you simply need to call into the attributes property of the alexa object. No more separate `put` and `get` functions!
 ```javascript
 this.attributes['yourAttribute'] = 'value';
 ```

 You can [create the table manually](http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SampleData.CreateTables.html) beforehand or simply give your Lambda function DynamoDB [create table permissions](http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html) and it will happen automatically. Just remember it can take a minute or so for the table to be created on the first invocation. If you create the table manually, the Primary Key must be a string value called "userId".

 ### Generating your own responses

 Normally emitting a response event like `this.emit(':tell', speechOutput, repromptSpeech)` will set up the response and send it to Alexa for you, using any speech or card values you pass it. If you want to manually create your own responses, you can use `this.response` to help. `this.response` contains a series of functions, that you can use to set the different properties of the response. This allows you to take advantage of the Alexa Skills Kit's built-in audio player support. Once you've set up your response, you can just call `this.emit(':responseReady')` to send your response to Alexa. The functions within `this.response` are also chainable, so you can use as many as you want in a row.

 For example, the below code is equivalent to `this.emit(':ask', 'foo', 'bar');`

 ```javascript
 this.response.speak('foo').listen('bar');
 this.emit(':responseReady');
 ```

 Here's the API for using `this.response`:

 - `this.response.speak(outputSpeech)`: sets the first speech output of the response to `outputSpeech`.
 - `this.response.listen(repromptSpeech)`: sets the reprompt speech of the response to `repromptSpeech` and `shouldEndSession` to false. Unless this function is called, `this.response` will set `shouldEndSession` to true.
 - `this.response.cardRenderer(cardTitle, cardContent, cardImage)`: sets the card in the response to have the title `cardTitle`, the content `cardContent`, and the image `cardImage`. `cardImage` can be excluded, but if it's included it must be of the correct image object format, detailed above.
 - `this.response.linkAccountCard()`: sets the type of the card to a 'Link Account' card.
 - `this.response.audioPlayer(directiveType, behavior, url, token, expectedPreviousToken, offsetInMilliseconds)`: sets the audioPlayer directive using the provided parameters. See the [audioPlayer interface reference](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/custom-audioplayer-interface-reference) for more details. Options for `directiveType` are `'play'`, `'stop'` and `'clearqueue'`. Inputting any other value is equivalent to `'clearqueue'`.
    - If you use `'play'`, you need to include all the parameters after: `behavior, url, token, expectedPreviousToken, offsetInMilliseconds`.
    - If you use `'stop'`, no further parameters are needed.
    - If you use `'clearQueue'`, you only need to include the `behaviour` parameter.
 - `this.response.audioPlayerPlay(behavior, url, token, expectedPreviousToken, offsetInMilliseconds)`: sets the audioPlayer directive using the provided parameters, and `AudioPlayer.Play` as the directive type. This will make the audio player play an audio file at a requested URL.
 - `this.response.audioPlayerStop()` sets the directive type to `AudioPlayer.Stop`. This will make the audio player stop.
 - `this.response.audioPlayerClearQueue(clearBehaviour)` sets the directive type to `AudioPlayer.ClearQueue` and sets the clear behaviour of the directive. Options for this value are `'CLEAR_ENQUEUED'` and `'CLEAR_ALL'`. This will either clear the queue and continue the current stream, or clear the queue and stop the current stream.

 When you've set up your response, simply call `this.emit(':responseReady');` to send your response off.

 ### Tips

 - When any of the response events are emitted `:ask`, `:tell`, `:askWithCard`, etc. The lambda context.succeed() method is called, which immediately stops processing of any further background tasks. Any asynchronous jobs that are still will not be completed and any lines of code below the response emit statement will not be executed. This is not the case for non responding events like `:saveState`.
 - In order to "transfer" a call from one state handler to another, `this.handler.state` needs to be set to the name of the target state. If the target state is "", then `this.emit("TargetHandlerName")` should be called. For any other states, `this.emitWithState("TargetHandlerName")` must be called instead.
 - The contents of the prompt and repompt values get wrapped in SSML tags. This means that any special XML characters within the value need to be escape coded. For example, this.emit(":ask", "I like M&M's") will cause a failure because the `&` character needs to be encoded as `&amp;`. Other characters that need to be encoded include: `<` -> `&lt;`, and `>` -> `&gt;`.

 ### Adding Multi-Language Support for Skill
 Let's take the Hello World example here. Define all user-facing language strings in the following format.
 ```javascript
 var languageStrings = {
    'en-GB': {
        'translation': {
            'SAY_HELLO_MESSAGE' : 'Hello World!'
        }
    },
    'en-US': {
        'translation': {
            'SAY_HELLO_MESSAGE' : 'Hello World!'
        }
    },
    'de-DE': {
        'translation': {
            'SAY_HELLO_MESSAGE' : 'Hallo Welt!'
        }
    }
 };
 ```

 To enable string internationalization features in Alexa-sdk, set resources to the object we created above.
 ```javascript
 exports.handler = function(event, context, callback) {
    var alexa = Alexa.handler(event, context);
    alexa.appId = appId;
    // To enable string internationalization (i18n) features, set a resources object.
    alexa.resources = languageStrings;
    alexa.registerHandlers(handlers);
    alexa.execute();
 };
 ```

 Once you are done defining and enabling language strings, you can access these strings using the this.t() function. Strings will be rendered in the language that matches the locale of the incoming request.
 ```javascript
 var handlers = {
    'LaunchRequest': function () {
        this.emit('SayHello');
    },
    'HelloWorldIntent': function () {
        this.emit('SayHello');
    },
    'SayHello': function () {
        this.emit(':tell', this.t('SAY_HELLO_MESSAGE'));
    }
 };
 ```
 For more infomation about developing and deploying skills in multiple languages, please go [here](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/developing-skills-in-multiple-languages).

 ### Device ID Support
 When a customer enables your Alexa skill, your skill can obtain the customer’s permission to use address data associated with the customer’s Alexa device. You can then use this address data to provide key functionality for the skill, or to enhance the customer experience.

 The `deviceId` is now exposed through the context object in each request and can be accessed in any intent handler through `this.event.context.System.device.deviceId`. See the [Address API sample skill](https://github.com/alexa/skill-sample-node-device-address-api) to see how we leveraged the deviceId and the Address API to use a user's device address in a skill.

 ### Speechcons (Interjections)

 [Speechcons](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/speechcon-reference) are special words and phrases that Alexa pronounces more expressively. In order to use them you can just include the SSML markup in the text to emit. 

 * `this.emit(':tell', 'Sometimes when I look at the Alexa skills you have all taught me, I just have to say, <say-as interpret-as="interjection">Bazinga.</say-as> ');`
 * `this.emit(':tell', '<say-as interpret-as="interjection">Oh boy</say-as><break time="1s"/> this is just an example.');`

 _Speechcons are supported for English (US), English (UK), and German._

 ### Dialog Management Support for Skill
 The `Dialog` interface provides directives for managing a multi-turn conversation between your skill and the user. You can use the directives to ask the user for the information you need to fulfill their request. See the [Dialog Interface](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/dialog-interface-reference) and [Skill Editor](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/ask-define-the-vui-with-gui) documentation for more information on how to use dialog directives.

 You can use `this.event.request.dialogState` to access current `dialogState`.

 #### Delegate Directive
 Sends Alexa a command to handle the next turn in the dialog with the user. You can use this directive if the skill has a dialog model and the current status of the dialog (`dialogState`) is either `STARTED` or `IN_PROGRESS`. You cannot emit this directive if the `dialogState` is `COMPLETED`.

 You can use `this.emit(':delegate')` to send delegate directive response.
 ```javascript
 var handlers = {
    'BookFlightIntent': function () {
        if (this.event.request.dialogState === 'STARTED') {
            var updatedIntent = this.event.request.intent;
            // Pre-fill slots: update the intent object with slot values for which
            // you have defaults, then emit :delegate with this updated intent.
            updatedIntent.slots.SlotName.value = 'DefaultValue';
            this.emit(':delegate', updatedIntent);
        } else if (this.event.request.dialogState !== 'COMPLETED'){
            this.emit(':delegate');
        } else {
            // All the slots are filled (And confirmed if you choose to confirm slot/intent)
            handlePlanMyTripIntent();
        }
    }
 };
 ```

 #### Elicit Slot Directive
 Sends Alexa a command to ask the user for the value of a specific slot. Specify the name of the slot to elicit in the `slotToElicit`. Provide a prompt to ask the user for the slot value in `speechOutput`.

 You can use `this.emit(':elicitSlot', slotToElicit, speechOutput, repromptSpeech, updatedIntent)` or `this.emit(':elicitSlotWithCard', slotToElicit, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj)` to send elicit slot directive response.

 When using `this.emit(':elicitSlotWithCard', slotToElicit, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj)`, `updatedIntent` and `imageObj` are optional parameters. You can set them to `null` or not pass them.
 ```javascript
 var handlers = {
    'BookFlightIntent': function () {
        var intentObj = this.event.request.intent;
        if (!intentObj.slots.Source.value) {
            var slotToElicit = 'Source';
            var speechOutput = 'Where would you like to fly from?';
            var repromptSpeech = speechOutput;
            this.emit(':elicitSlot', slotToElicit, speechOutput, repromptSpeech);
        } else if (!intentObj.slots.Destination.value) {
            var slotToElicit = 'Destination';
            var speechOutput = 'Where would you like to fly to?';
            var repromptSpeech = speechOutput;
            var cardContent = 'What is the destination?';
            var cardTitle = 'Destination';
            var updatedIntent = intentObj;
            // An intent object representing the intent sent to your skill.
            // You can use this property set or change slot values and confirmation status if necessary.
            var imageObj = {
                smallImageUrl: 'https://imgs.xkcd.com/comics/standards.png',
                largeImageUrl: 'https://imgs.xkcd.com/comics/standards.png'
            };
            this.emit(':elicitSlotWithCard', slotToElicit, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj);
        } else {
            handlePlanMyTripIntentAllSlotsAreFilled();
        }
    }
 };
 ```

 #### Confirm Slot Directive
 Sends Alexa a command to confirm the value of a specific slot before continuing with the dialog. Specify the name of the slot to confirm in the `slotToConfirm`. Provide a prompt to ask the user for confirmation in `speechOutput`.

 You can use `this.emit(':confirmSlot', slotToConfirm, speechOutput, repromptSpeech, updatedIntent)` or `this.emit(':confirmSlotWithCard', slotToConfirm, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj)` to send confirm slot directive response.

 When using `this.emit(':confirmSlotWithCard', slotToConfirm, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj)`, `updatedIntent` and `imageObj` are optional parameters. You can set them to `null` or not pass them.
 ```javascript
 var handlers = {
    'BookFlightIntent': function () {
        var intentObj = this.event.request.intent;
        if (intentObj.slots.Source.confirmationStatus !== 'CONFIRMED') {
            if (intentObj.slots.Source.confirmationStatus !== 'DENIED') {
                // Slot value is not confirmed
                var slotToConfirm = 'Source';
                var speechOutput = 'You want to fly from ' + intentObj.slots.Source.value + ', is that correct?';
                var repromptSpeech = speechOutput;
                this.emit(':confirmSlot', slotToConfirm, speechOutput, repromptSpeech);
            } else {
                // Users denies the confirmation of slot value
                var slotToElicit = 'Source';
                var speechOutput = 'Okay, Where would you like to fly from?';
                this.emit(':elicitSlot', slotToElicit, speechOutput, speechOutput);
            }
        } else if (intentObj.slots.Destination.confirmationStatus !== 'CONFIRMED') {
            if (intentObj.slots.Destination.confirmationStatus !== 'DENIED') {
                var slotToConfirm = 'Destination';
                var speechOutput = 'You would like to fly to ' + intentObj.slots.Destination.value + ', is that correct?';
                var repromptSpeech = speechOutput;
                var cardContent = speechOutput;
                var cardTitle = 'Confirm Destination';
                this.emit(':confirmSlotWithCard', slotToConfirm, speechOutput, repromptSpeech, cardTitle, cardContent);
            } else {
                var slotToElicit = 'Destination';
                var speechOutput = 'Okay, Where would you like to fly to?';
                var repromptSpeech = speechOutput;
                this.emit(':elicitSlot', slotToElicit, speechOutput, repromptSpeech);
            }
        } else {
            handlePlanMyTripIntentAllSlotsAreConfirmed();
        }
    }
 };
 ```

 #### Confirm Intent Directive
 Sends Alexa a command to confirm the all the information the user has provided for the intent before the skill takes action. Provide a prompt to ask the user for confirmation in `speechOutput`. Be sure to repeat back all the values the user needs to confirm in the prompt.

 You can use `this.emit(':confirmIntent', speechOutput, repromptSpeech, updatedIntent)` or `this.emit(':confirmIntentWithCard', speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj)` to send confirm intent directive response.

 When using `this.emit(':confirmIntentWithCard', speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj)`, `updatedIntent` and `imageObj` are optional parameters. You can set them to `null` or not pass them.
 ```javascript
 var handlers = {
    'BookFlightIntent': function () {
        var intentObj = this.event.request.intent;
        if (intentObj.confirmationStatus !== 'CONFIRMED') {
            if (intentObj.confirmationStatus !== 'DENIED') {
                // Intent is not confirmed
                var speechOutput = 'You would like to book flight from ' + intentObj.slots.Source.value + ' to ' +
                intentObj.slots.Destination.value + ', is that correct?';
                var cardTitle = 'Booking Summary';
                var repromptSpeech = speechOutput;
                var cardContent = speechOutput;
                this.emit(':confirmIntentWithCard', speechOutput, repromptSpeech, cardTitle, cardContent);
            } else {
                // Users denies the confirmation of intent. May be value of the slots are not correct.
                handleIntentConfimationDenial();
            }
        } else {
            handlePlanMyTripIntentAllSlotsAndIntentAreConfirmed();
        }
    }
 };
 ```

 ### Next Steps

 Try extending the HighLow game:

 - Have it store your average number of guesses per game
 - Add [sound effects](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/speech-synthesis-markup-language-ssml-reference#audio)
 - Give the player a limited amount of guesses

 For more information about getting started with the Alexa Skills Kit, check out the following additional assets:

 [Alexa Dev Chat Podcast](http://bit.ly/alexadevchat)

 [Alexa Training with Big Nerd Ranch](https://developer.amazon.com/public/community/blog/tag/Big+Nerd+Ranch)

 [Alexa Skills Kit (ASK)](https://developer.amazon.com/ask)

 [Alexa Developer Forums](https://forums.developer.amazon.com/forums/category.jspa?categoryID=48)

 [Training for the Alexa Skills Kit](https://developer.amazon.com/alexa-skills-kit/alexa-skills-developer-training)

 -Dave ( [@TheDaveDev](http://twitter.com/thedavedev))
--- a/src/node_modules/alexa-sdk/dist/BUNDLE_LICENSE.txt
+++ b/src/node_modules/alexa-sdk/dist/BUNDLE_LICENSE.txt
@@ -1,96 +0,0 @@
 The bundled package of the Alexa SDK for JavaScript is available under the
 Apache License, Version 2.0:

  Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.

  Licensed under the Apache License, Version 2.0 (the "License"). You
  may not use this file except in compliance with the License. A copy of
  the License is located at

      http://aws.amazon.com/apache2.0/

  or in the "license" file accompanying this file. This file is
  distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
  ANY KIND, either express or implied. See the License for the specific
  language governing permissions and limitations under the License.

 This product bundles browserify, which is available under a
 "3-clause BSD" license:

  Copyright Joyent, Inc. and other Node contributors.

  Permission is hereby granted, free of charge, to any person obtaining a
  copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to permit
  persons to whom the Software is furnished to do so, subject to the
  following conditions:

  The above copyright notice and this permission notice shall be included
  in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  USE OR OTHER DEALINGS IN THE SOFTWARE.

 This product bundles crypto-browserify, which is available under
 the MIT license:

  Copyright (c) 2013 Dominic Tarr

  Permission is hereby granted, free of charge,
  to any person obtaining a copy of this software and
  associated documentation files (the "Software"), to
  deal in the Software without restriction, including
  without limitation the rights to use, copy, modify,
  merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom
  the Software is furnished to do so,
  subject to the following conditions:

  The above copyright notice and this permission notice
  shall be included in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 This product bundles MD5, SHA-1, and SHA-256 hashing algorithm components,
 which are available under a BSD license:

  Copyright (c) 1998 - 2009, Paul Johnston & Contributors
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

  Redistributions of source code must retain the above copyrightnotice,
  this list of conditions and the following disclaimer. Redistributions
  in binary form must reproduce the above copyright notice, this list of
  conditions and the following disclaimer in the documentation and/or
  other materials provided with the distribution.

  Neither the name of the author nor the names of its contributors may
  be used to endorse or promote products derived from this software
  without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  THE POSSIBILITY OF SUCH DAMAGE.
--- a/src/node_modules/alexa-sdk/index.js
+++ b/src/node_modules/alexa-sdk/index.js
@@ -1,5 +0,0 @@
 var AlexaLambdaHandler = require('./lib/alexa');

 module.exports.handler = AlexaLambdaHandler.LambdaHandler;
 module.exports.CreateStateHandler = AlexaLambdaHandler.CreateStateHandler;
 module.exports.StateString = AlexaLambdaHandler.StateString;
--- a/src/node_modules/alexa-sdk/lib/DynamoAttributesHelper.js
+++ b/src/node_modules/alexa-sdk/lib/DynamoAttributesHelper.js
@@ -1,99 +0,0 @@
 'use strict';
 var aws = require('aws-sdk');
 var doc;

 module.exports = (function() {
    return {
        get: function(table, userId, callback) {
            if(!table) {
                callback('DynamoDB Table name is not set.', null);
            }

            if(!doc) {
                doc = new aws.DynamoDB.DocumentClient({apiVersion: '2012-08-10'});
            }

            var params = {
                Key: {
                    userId: userId
                },
                TableName: table,
                ConsistentRead: true
            };

            doc.get(params, function(err, data){
                if(err) {
                    console.log('get error: ' + JSON.stringify(err, null, 4));

                    if(err.code === 'ResourceNotFoundException') {
                        var dynamoClient = new aws.DynamoDB();
                        newTableParams['TableName'] = table;
                        dynamoClient.createTable(newTableParams, function (err, data) {
                            if(err) {
                                console.log('Error creating table: ' + JSON.stringify(err, null, 4));
                            }
                            console.log('Creating table ' + table + ':\n' + JSON.stringify(data));
                            callback(err, {});
                        });
                    } else {
                        callback(err, null);
                    }
                } else {
                    if(isEmptyObject(data)) {
                        callback(null, {});
                    } else {
                        callback(null, data.Item['mapAttr']);
                    }
                }
            });
        },

        set: function(table, userId, data, callback) {
            if(!table) {
                callback('DynamoDB Table name is not set.', null);
            }

            if(!doc) {
                doc = new aws.DynamoDB.DocumentClient({apiVersion: '2012-08-10'});
            }

            var params = {
                Item: {
                    userId: userId,
                    mapAttr: data
                },
                TableName: table
            };

            doc.put(params, function(err, data) {
                if(err) {
                    console.log('Error during DynamoDB put:' + err);
                }
                callback(err, data);
            });
        }
    };
 })();

 function isEmptyObject(obj) {
    return !Object.keys(obj).length;
 }

 var newTableParams = {
    AttributeDefinitions: [
        {
            AttributeName: 'userId',
            AttributeType: 'S'
        }
    ],
    KeySchema: [
        {
            AttributeName: 'userId',
            KeyType: 'HASH'
        }
    ],
    ProvisionedThroughput: {
        ReadCapacityUnits: 5,
        WriteCapacityUnits: 5
    }
 };
--- a/src/node_modules/alexa-sdk/lib/alexa.js
+++ b/src/node_modules/alexa-sdk/lib/alexa.js
@@ -1,437 +0,0 @@
 'use strict';

 var EventEmitter = require('events').EventEmitter;
 var util = require('util');
 var i18n = require('i18next');
 var sprintf = require('i18next-sprintf-postprocessor');
 var attributesHelper = require('./DynamoAttributesHelper');
 var responseHandlers = require('./response');
 var _StateString = 'STATE';

 function AlexaRequestEmitter() {
    EventEmitter.call(this);
 }

 util.inherits(AlexaRequestEmitter, EventEmitter);

 function alexaRequestHandler(event, context, callback) {
    if (!event.session) {
        event.session = { 'attributes': {} };
    } else if (!event.session['attributes']) {
        event.session['attributes'] = {};
    }

    var handler = new AlexaRequestEmitter();
    handler.setMaxListeners(Infinity);

    Object.defineProperty(handler, '_event', {
        value: event,
        writable: false
    });

    Object.defineProperty(handler, '_context', {
        value: context,
        writable: false
    });

    Object.defineProperty(handler, '_callback', {
        value: callback,
        writable: false
    });

    Object.defineProperty(handler, 'state', {
        value: null,
        writable: true,
        configurable: true
    });

    Object.defineProperty(handler, 'appId', {
        value: null,
        writable: true
    });

    Object.defineProperty(handler, 'response', {
        value: {},
        writable: true
    });

    Object.defineProperty(handler, 'dynamoDBTableName', {
        value: null,
        writable: true
    });

    Object.defineProperty(handler, 'saveBeforeResponse', {
        value: false,
        writable: true
    });

    Object.defineProperty(handler, 'i18n', {
        value: i18n,
        writable: true
    });

    Object.defineProperty(handler, 'locale', {
        value: undefined,
        writable: true
    });

    Object.defineProperty(handler, 'resources', {
        value: undefined,
        writable: true
    });

    Object.defineProperty(handler, 'registerHandlers', {
        value: function() {
            RegisterHandlers.apply(handler, arguments);
        },
        writable: false
    });

    Object.defineProperty(handler, 'execute', {
        value: function() {
            HandleLambdaEvent.call(handler);
        },
        writable: false
    });

    handler.registerHandlers(responseHandlers);

    return handler;
 }

 function HandleLambdaEvent() {
    this.locale = this._event.request.locale;
    if(this.resources) {
        this.i18n.use(sprintf).init({
            overloadTranslationOptionHandler: sprintf.overloadTranslationOptionHandler,
            returnObjects: true,
            lng: this.locale,
            resources: this.resources
        }, (err, t) => {
            if(err) {
                throw new Error('Error initializing i18next: ' + err);
            }
            ValidateRequest.call(this);
        });
    } else {
        ValidateRequest.call(this);
    }
 }

 function ValidateRequest() {
    var event = this._event;
    var context = this._context;
    var callback = this._callback;
    var handlerAppId = this.appId;

    var requestAppId = '';
    var userId = '';

    // Long-form audio enabled skills use event.context
    if (event.context) {
        requestAppId = event.context.System.application.applicationId;
        userId = event.context.System.user.userId;
    } else if (event.session) {
        requestAppId = event.session.application.applicationId;
        userId = event.session.user.userId;
    }


    if(!handlerAppId){
        console.log('Warning: Application ID is not set');
    }

    try {
        // Validate that this request originated from authorized source.
        if (handlerAppId && (requestAppId !== handlerAppId)) {
            console.log(`The applicationIds don\'t match: ${requestAppId} and ${handlerAppId}`);
            var error = new Error('Invalid ApplicationId: ' + handlerAppId)
            if(typeof callback === 'undefined') {
                return context.fail(error)
            } else {
                return callback(error);
            }
        }

        if(this.dynamoDBTableName && (!event.session.sessionId || event.session['new']) ) {
            attributesHelper.get(this.dynamoDBTableName, userId, (err, data) => {
                if(err) {
                    var error = new Error('Error fetching user state: ' + err)
                    if(typeof callback === 'undefined') {
                        return context.fail(error)
                    } else {
                        return  callback(error);
                    }
                }

                Object.assign(this._event.session.attributes, data);

                EmitEvent.call(this);
            });
        } else {
            EmitEvent.call(this);
        }
    } catch (e) {
        console.log(`Unexpected exception '${e}':\n${e.stack}`);
        if(typeof callback === 'undefined') {
            return context.fail(e)
        } else {
            return  callback(e);
        }
    }
 }

 function EmitEvent() {
    this.state = this._event.session.attributes[_StateString] || '';

    var eventString = '';

    if (this._event.session['new'] && this.listenerCount('NewSession' + this.state) === 1) {
        eventString = 'NewSession';
    } else if(this._event.request.type === 'LaunchRequest') {
        eventString = 'LaunchRequest';
    } else if(this._event.request.type === 'IntentRequest') {
        eventString = this._event.request.intent.name;
    } else if (this._event.request.type === 'SessionEndedRequest'){
        eventString = 'SessionEndedRequest';
    } else if (this._event.request.type.substring(0,11) === 'AudioPlayer') {
        eventString = this._event.request.type.substring(12);
    } else if (this._event.request.type.substring(0,18) === 'PlaybackController') {
        eventString = this._event.request.type.substring(19);
    } else if (this._event.request.type === 'Display.ElementSelected') {
        eventString = 'ElementSelected';
    }

    eventString += this.state;

    if(this.listenerCount(eventString) < 1) {
        eventString = 'Unhandled' + this.state;
    }

    if(this.listenerCount(eventString) < 1){
        throw new Error(`No 'Unhandled' function defined for event: ${eventString}`);
    }

    this.emit(eventString);
 }

 function RegisterHandlers() {
    for(var arg = 0; arg < arguments.length; arg++) {
        var handlerObject = arguments[arg];

        if(!isObject(handlerObject)) {
            throw new Error(`Argument #${arg} was not an Object`);
        }

        var eventNames = Object.keys(handlerObject);

        for(var i = 0; i < eventNames.length; i++) {
            if(typeof(handlerObject[eventNames[i]]) !== 'function') {
                throw new Error(`Event handler for '${eventNames[i]}' was not a function`);
            }

            var eventName = eventNames[i];

            if(handlerObject[_StateString]) {
                eventName += handlerObject[_StateString];
            }

            var localize = function() {
                return this.i18n.t.apply(this.i18n, arguments);
            };

            var handlerContext = {
                on: this.on.bind(this),
                emit: this.emit.bind(this),
                emitWithState: EmitWithState.bind(this),
                state: this.state,
                handler: this,
                i18n: this.i18n,
                locale: this.locale,
                t : localize,
                event: this._event,
                attributes: this._event.session.attributes,
                context: this._context,
                callback : this._callback,
                name: eventName,
                isOverridden:  IsOverridden.bind(this, eventName),
                response: ResponseBuilder(this)
            };

            this.on(eventName, handlerObject[eventNames[i]].bind(handlerContext));
        }
    }
 }

 function isObject(obj) {
    return (!!obj) && (obj.constructor === Object);
 }

 function IsOverridden(name) {
    return this.listenerCount(name) > 1;
 }

 function ResponseBuilder(self) {
    var responseObject = self.response;
    responseObject.version = '1.0';
    responseObject.response = {
        shouldEndSession: true
    };
    responseObject.sessionAttributes = self._event.session.attributes;

    return (function () {
        return {
            'speak': function (speechOutput) {
                responseObject.response.outputSpeech = createSSMLSpeechObject(speechOutput);
                return this;
            },
            'listen': function (repromptSpeech) {
                responseObject.response.reprompt = {
                    outputSpeech: createSSMLSpeechObject(repromptSpeech)
                };
                responseObject.response.shouldEndSession = false;
                return this;
            },
            'cardRenderer': function (cardTitle, cardContent, cardImage) {
                var card = {
                    type: 'Simple',
                    title: cardTitle,
                    content: cardContent
                };

                if(cardImage && (cardImage.smallImageUrl || cardImage.largeImageUrl)) {
                    card.type = 'Standard';
                    card['image'] = {};

                    delete card.content;
                    card.text = cardContent;

                    if(cardImage.smallImageUrl) {
                        card.image['smallImageUrl'] = cardImage.smallImageUrl;
                    }

                    if(cardImage.largeImageUrl) {
                        card.image['largeImageUrl'] = cardImage.largeImageUrl;
                    }
                }

                responseObject.response.card = card;
                return this;
            },
            'linkAccountCard': function () {
                responseObject.response.card = {
                    type: 'LinkAccount'
                };
                return this;
            },
            'audioPlayer': function (directiveType, behavior, url, token, expectedPreviousToken, offsetInMilliseconds) {
                var audioPlayerDirective;
                if (directiveType === 'play') {
                    audioPlayerDirective = {
                        "type": "AudioPlayer.Play",
                        "playBehavior": behavior,
                        "audioItem": {
                            "stream": {
                                "url": url,
                                "token": token,
                                "expectedPreviousToken": expectedPreviousToken,
                                "offsetInMilliseconds": offsetInMilliseconds
                            }
                        }
                    };
                } else if (directiveType === 'stop') {
                    audioPlayerDirective = {
                        "type": "AudioPlayer.Stop"
                    };
                } else {
                    audioPlayerDirective = {
                        "type": "AudioPlayer.ClearQueue",
                        "clearBehavior": behavior
                    };
                }

                responseObject.response.directives = [audioPlayerDirective];
                return this;
            },
            'audioPlayerPlay': function (behavior, url, token, expectedPreviousToken, offsetInMilliseconds) {
                var audioPlayerDirective = {
                    "type": "AudioPlayer.Play",
                    "playBehavior": behavior,
                    "audioItem": {
                        "stream": {
                            "url": url,
                            "token": token,
                            "expectedPreviousToken": expectedPreviousToken,
                            "offsetInMilliseconds": offsetInMilliseconds
                        }
                    }
                };

                responseObject.response.directives = [audioPlayerDirective];
                return this;
            },
            'audioPlayerStop': function () {
                var audioPlayerDirective = {
                    "type": "AudioPlayer.Stop"
                };

                responseObject.response.directives = [audioPlayerDirective];
                return this;
            },
            'audioPlayerClearQueue': function (clearBehavior) {
                var audioPlayerDirective = {
                    "type": "AudioPlayer.ClearQueue",
                    "clearBehavior": clearBehavior
                };

                responseObject.response.directives = [audioPlayerDirective];
                return this;
            }
        }
    })();
 }

 function createSSMLSpeechObject(message) {
    return {
        type: 'SSML',
        ssml: `<speak> ${message} </speak>`
    };
 }

 function createStateHandler(state, obj){
    if(!obj) {
        obj = {};
    }

    Object.defineProperty(obj, _StateString, {
        value: state || ''
    });

    return obj;
 }

 function EmitWithState() {
    if(arguments.length === 0) {
        throw new Error('EmitWithState called without arguments');
    }
    arguments[0] = arguments[0] + this.state;

    if (this.listenerCount(arguments[0]) < 1) {
        arguments[0] = 'Unhandled' + this.state;
    }

    if (this.listenerCount(arguments[0]) < 1) {
        throw new Error(`No 'Unhandled' function defined for event: ${arguments[0]}`);
    }

    this.emit.apply(this, arguments);
 }

 process.on('uncaughtException', function(err) {
    console.log(`Uncaught exception: ${err}\n${err.stack}`);
    throw err;
 });

 module.exports.LambdaHandler = alexaRequestHandler;
 module.exports.CreateStateHandler = createStateHandler;
 module.exports.StateString = _StateString;
--- a/src/node_modules/alexa-sdk/lib/response.js
+++ b/src/node_modules/alexa-sdk/lib/response.js
@@ -1,364 +0,0 @@
 'use strict';
 var attributesHelper = require('./DynamoAttributesHelper');

 module.exports = (function () {
    return {
        ':tell': function (speechOutput) {
            if(this.isOverridden()) {
                return;
            }

            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                shouldEndSession: true
            });
            this.emit(':responseReady');
        },
        ':ask': function (speechOutput, repromptSpeech) {
            if(this.isOverridden()) {
                return;
            }
            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':askWithCard': function(speechOutput, repromptSpeech, cardTitle, cardContent, imageObj) {
            if(this.isOverridden()) {
                return;
            }

            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                cardTitle: cardTitle,
                cardContent: cardContent,
                cardImage: imageObj,
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':tellWithCard': function(speechOutput, cardTitle, cardContent, imageObj) {
            if(this.isOverridden()) {
                return;
            }

            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                cardTitle: cardTitle,
                cardContent: cardContent,
                cardImage: imageObj,
                shouldEndSession: true
            });
            this.emit(':responseReady');
        },
        ':tellWithLinkAccountCard': function(speechOutput) {
            if(this.isOverridden()) {
                return;
            }

            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                cardType: 'LinkAccount',
                shouldEndSession: true
            });
            this.emit(':responseReady');
        },
        ':askWithLinkAccountCard': function(speechOutput, repromptSpeech) {
            if(this.isOverridden()) {
                return;
            }

            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                cardType: 'LinkAccount',
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':tellWithPermissionCard': function(speechOutput, permissions) {
            if(this.isOverridden()) {
                return;
            }

            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                permissions: permissions,
                cardType: 'AskForPermissionsConsent',
                shouldEndSession: true
            });
            this.emit(':responseReady');
        },
        ':delegate': function(updatedIntent) {
            if(this.isOverridden()) {
                return;
            }

            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                directives: getDialogDirectives('Dialog.Delegate', updatedIntent, null),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':elicitSlot': function (slotName, speechOutput, repromptSpeech, updatedIntent) {
            if(this.isOverridden()) {
                return;
            }
            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                directives: getDialogDirectives('Dialog.ElicitSlot', updatedIntent, slotName),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':elicitSlotWithCard': function (slotName, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj) {
            if(this.isOverridden()) {
                return;
            }
            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                cardTitle: cardTitle,
                cardContent: cardContent,
                cardImage: imageObj,
                directives: getDialogDirectives('Dialog.ElicitSlot', updatedIntent, slotName),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':confirmSlot': function (slotName, speechOutput, repromptSpeech, updatedIntent) {
            if(this.isOverridden()) {
                return;
            }
            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                directives: getDialogDirectives('Dialog.ConfirmSlot', updatedIntent, slotName),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':confirmSlotWithCard': function (slotName, speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj) {
            if(this.isOverridden()) {
                return;
            }
            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                cardTitle: cardTitle,
                cardContent: cardContent,
                cardImage: imageObj,
                directives: getDialogDirectives('Dialog.ConfirmSlot', updatedIntent, slotName),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':confirmIntent': function (speechOutput, repromptSpeech, updatedIntent) {
            if(this.isOverridden()) {
                return;
            }
            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                directives: getDialogDirectives('Dialog.ConfirmIntent', updatedIntent, null),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':confirmIntentWithCard': function (speechOutput, repromptSpeech, cardTitle, cardContent, updatedIntent, imageObj) {
            if(this.isOverridden()) {
                return;
            }
            this.handler.response = buildSpeechletResponse({
                sessionAttributes: this.attributes,
                output: getSSMLResponse(speechOutput),
                reprompt: getSSMLResponse(repromptSpeech),
                cardTitle: cardTitle,
                cardContent: cardContent,
                cardImage: imageObj,
                directives: getDialogDirectives('Dialog.ConfirmIntent', updatedIntent, null),
                shouldEndSession: false
            });
            this.emit(':responseReady');
        },
        ':responseReady': function () {
            if (this.isOverridden()) {
                return;
            }

            if(this.handler.state) {
                this.handler.response.sessionAttributes['STATE'] = this.handler.state;
            }

            if (this.handler.dynamoDBTableName) {
                this.emit(':saveState');
            }

            if(typeof this.callback === 'undefined') {
                this.context.succeed(this.handler.response);
            } else {
                this.callback(null, this.handler.response);
            }
        },
        ':saveState': function(forceSave) {
            if (this.isOverridden()) {
                return;
            }

            if(forceSave && this.handler.state){
                this.attributes['STATE'] = this.handler.state;
            }

            var userId = '';

            // Long-form audio enabled skills use event.context
            if (this.event.context) {
                userId = this.event.context.System.user.userId;
            } else if (this.event.session) {
                userId = this.event.session.user.userId;
            }

            if(this.handler.saveBeforeResponse || forceSave || this.handler.response.response.shouldEndSession) {
                attributesHelper.set(this.handler.dynamoDBTableName, userId, this.attributes, (err) => {
                    if(err) {
                        return this.emit(':saveStateError', err);
                    }
                });
            }
        },
        ':saveStateError': function(err) {
            if(this.isOverridden()) {
                return;
            }
            console.log(`Error saving state: ${err}\n${err.stack}`);
            if(typeof this.callback === 'undefined') {
                this.context.fail(err);
            } else {
                this.callback(err);
            }
        }
    };
 })();

 function createSpeechObject(optionsParam) {
    if (optionsParam && optionsParam.type === 'SSML') {
        return {
            type: optionsParam.type,
            ssml: optionsParam['speech']
        };
    } else {
        return {
            type: optionsParam.type || 'PlainText',
            text: optionsParam['speech'] || optionsParam
        };
    }
 }

 function buildSpeechletResponse(options) {
    var alexaResponse = {
        shouldEndSession: options.shouldEndSession
    };

    if (options.output) {
        alexaResponse.outputSpeech = createSpeechObject(options.output);
    }

    if (options.reprompt) {
        alexaResponse.reprompt = {
            outputSpeech: createSpeechObject(options.reprompt)
        };
    }

    if (options.directives) {
        alexaResponse.directives = options.directives;
    }

    if (options.cardTitle && options.cardContent) {
        alexaResponse.card = {
            type: 'Simple',
            title: options.cardTitle,
            content: options.cardContent
        };

        if(options.cardImage && (options.cardImage.smallImageUrl || options.cardImage.largeImageUrl)) {
            alexaResponse.card.type = 'Standard';
            alexaResponse.card['image'] = {};

            delete alexaResponse.card.content;
            alexaResponse.card.text = options.cardContent;

            if(options.cardImage.smallImageUrl) {
                alexaResponse.card.image['smallImageUrl'] = options.cardImage.smallImageUrl;
            }

            if(options.cardImage.largeImageUrl) {
                alexaResponse.card.image['largeImageUrl'] = options.cardImage.largeImageUrl;
            }
        }
    } else if (options.cardType === 'LinkAccount') {
        alexaResponse.card = {
            type: 'LinkAccount'
        };
    } else if (options.cardType === 'AskForPermissionsConsent') {
        alexaResponse.card = {
            type: 'AskForPermissionsConsent',
            permissions: options.permissions
        };
    }

    var returnResult = {
        version: '1.0',
        response: alexaResponse
    };

    if (options.sessionAttributes) {
        returnResult.sessionAttributes = options.sessionAttributes;
    }
    return returnResult;
 }

 // TODO: check for ssml content in card
 function getSSMLResponse(message) {
    if (message == null) {
        return null;
    } else {
        return {
            type: 'SSML',
            speech: `<speak> ${message} </speak>`
        };
    }
 }

 function getDialogDirectives(dialogType, updatedIntent, slotName) {
    let directive = {
        type: dialogType
    };

    if (dialogType === 'Dialog.ElicitSlot') {
        directive.slotToElicit = slotName;
    } else if (dialogType === 'Dialog.ConfirmSlot') {
        directive.slotToConfirm = slotName;
    }

    if (updatedIntent) {
        directive.updatedIntent = updatedIntent;
    }
    return [directive];
 }
--- a/src/node_modules/alexa-sdk/package.json
+++ b/src/node_modules/alexa-sdk/package.json
@@ -1,110 +0,0 @@
 {
  "_args": [
    [
      "alexa-sdk@^1.0.6",
      "/home/binhong/dota2-alexa-skill/src"
    ]
  ],
  "_from": "alexa-sdk@>=1.0.6 <2.0.0",
  "_id": "alexa-sdk@1.0.11",
  "_inCache": true,
  "_installable": true,
  "_location": "/alexa-sdk",
  "_nodeVersion": "6.9.1",
  "_npmOperationalInternal": {
    "host": "s3://npm-registry-packages",
    "tmp": "tmp/alexa-sdk-1.0.11.tgz_1498871748051_0.3228772508446127"
  },
  "_npmUser": {
    "email": "alexa-lantern-team@amazon.com",
    "name": "alexalantern"
  },
  "_npmVersion": "3.10.8",
  "_phantomChildren": {},
  "_requested": {
    "name": "alexa-sdk",
    "raw": "alexa-sdk@^1.0.6",
    "rawSpec": "^1.0.6",
    "scope": null,
    "spec": ">=1.0.6 <2.0.0",
    "type": "range"
  },
  "_requiredBy": [
    "/"
  ],
  "_resolved": "https://registry.npmjs.org/alexa-sdk/-/alexa-sdk-1.0.11.tgz",
  "_shasum": "bbc5d95c9878bc76c4b48f7909ad620c81044995",
  "_shrinkwrap": null,
  "_spec": "alexa-sdk@^1.0.6",
  "_where": "/home/binhong/dota2-alexa-skill/src",
  "author": {
    "name": "Amazon.com"
  },
  "bugs": {
    "url": "https://github.com/alexa/alexa-skill-sdk-for-nodejs/issues"
  },
  "contributors": [
    {
      "name": "Diego Benitez",
      "email": "diegoben@amazon.com"
    },
    {
      "name": "Yang Zhang",
      "email": "ygzg@amazon.com"
    },
    {
      "name": "Brendan Clement",
      "email": "clebrend@amazon.com"
    },
    {
      "name": "Leandro Pascual",
      "email": "leandrop@amazon.com"
    },
    {
      "name": "Krish Furia",
      "email": "krishf@amazon.com"
    }
  ],
  "dependencies": {
    "aws-sdk": "^2.4.7",
    "i18next": "^3.4.1",
    "i18next-sprintf-postprocessor": "^0.2.2"
  },
  "description": "Alexa Skill SDK for Node.js",
  "devDependencies": {},
  "directories": {},
  "dist": {
    "shasum": "bbc5d95c9878bc76c4b48f7909ad620c81044995",
    "tarball": "https://registry.npmjs.org/alexa-sdk/-/alexa-sdk-1.0.11.tgz"
  },
  "gitHead": "3c91133e99ab404d7aeb6765cb01ecb2100494da",
  "homepage": "https://github.com/alexa/alexa-skill-sdk-for-nodejs#readme",
  "keywords": [
    "Alexa",
    "sdk",
    "skill"
  ],
  "license": "Apache-2.0",
  "main": "index.js",
  "maintainers": [
    {
      "name": "alexalantern",
      "email": "alexa-lantern-team@amazon.com"
    },
    {
      "name": "diegoben",
      "email": "alexa-npm-admin@amazon.com"
    }
  ],
  "name": "alexa-sdk",
  "optionalDependencies": {},
  "readme": "ERROR: No README data found!",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/alexa/alexa-skill-sdk-for-nodejs.git"
  },
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "version": "1.0.11"
 }
--- a/src/node_modules/aws-sdk/.changes/2.10.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.10.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "JSON",
        "description": "Fixes issue caused when trying to unmarshall null binary shapes."
    },
    {
        "type": "bugfix",
        "category": "TypeScript",
        "description": "Add `credentialProvider` as an optional parameter of `ConfigurationOptions`."
    },
    {
        "type": "feature",
        "category": "LexRuntime",
        "description": "Amazon Lex is a service for building conversational interactions into any application using voice or text."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.11.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.11.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "TypeScript",
        "description": "Add `endpoint` property to AWS.S3 instance declaration."
    },
    {
        "type": "feature",
        "category": "EC2",
        "description": "This feature allows customers to associate an IAM profile to running instances that do not have any."
    },
    {
        "type": "feature",
        "category": "Rekognition",
        "description": "DetectFaces and IndexFaces operations now return an estimate of the age of the face as an age range."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.12.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.12.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "StorageGateway",
        "description": "File gateway mode in AWS Storage gateway provides access to objects in S3 as files on a Network File System (NFS) mount point. This is done by creating Nfs file shares using existing APIs CreateNfsFileShare. Using the feature in this update, the customer can restrict the clients that have read/write access to the gateway by specifying the list of clients as a list of IP addresses or CIDR blocks. This list can be specified using the API CreateNfsFileShare while creating new file shares, or UpdateNfsFileShare while update existing file shares. To find out the list of clients that have access, the existing API DescribeNfsFileShare will now output the list of clients that have access."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.13.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.13.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "Ec2",
        "description": "Adds support for the new Modify Volumes apis."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.14.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.14.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "KMS",
        "description": "This release of AWS Key Management Service introduces the ability to tag keys. Tagging keys can help you organize your keys and track your KMS costs in the cost allocation report. This release also increases the maximum length of a key ID to accommodate ARNs that include a long key alias."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.15.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.15.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CognitoIdentity",
        "description": "Allows createIdentityPool and updateIdentityPool API to set server side token check value on identity pool."
    },
    {
        "type": "feature",
        "category": "ConfigService",
        "description": "AWS Config now supports a new test mode for the PutEvaluations API. Set the TestMode parameter to true in your custom rule to verify whether your AWS Lambda function will deliver evaluation results to AWS Config. No updates occur to your existing evaluations, and evaluation results are not sent to AWS Config."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.16.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.16.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DirectConnect",
        "description": "This update will introduce the ability for Direct Connect customers to take advantage of Link Aggregation (LAG). This allows you to bundle many individual physical interfaces into a single logical interface, referred to as a LAG. This makes administration much simpler as the majority of configuration is done on the LAG while you are free to add or remove physical interfaces from the bundle as bandwidth demand increases or decreases. A concrete example of the simplification added by LAG is that customers need only a single BGP session as opposed to one session per physical connection."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.17.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.17.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "TypeScript",
        "description": "Enable the configuration credentials to be nulled so that the global config is not used."
    },
    {
        "type": "feature",
        "category": "EC2",
        "description": "Added the billingProduct parameter to the RegisterImage API."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.18.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.18.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "GameLift",
        "description": "Allow developers to configure global queues for creating GameSessions. Allow PlayerData on PlayerSessions to store player-specific data."
    },
    {
        "type": "feature",
        "category": "Route53",
        "description": "Added support for operations CreateVPCAssociationAuthorization and DeleteVPCAssociationAuthorization to throw a ConcurrentModification error when a conflicting modification occurs in parallel to the authorizations in place for a given hosted zone."
    },
    {
        "type": "feature",
        "category": "ElasticBeanstalk",
        "description": "Elastic Beanstalk adds support for creating and managing custom platform."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.19.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.19.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "XHR",
        "description": "Fixes an issue where the callback provided to an operation would not fire if a request was aborted after being sent. The bug only affected the browser SDK."
    },
    {
        "type": "feature",
        "category": "S3",
        "description": "Added an instance method to S3 clients to create POST form data with presigned upload policies"
    },
    {
        "type": "feature",
        "category": "DynamoDB",
        "description": "Expose DynamoDB DocumentClient marshaller/unmarshaller as AWS.DynamoDB.Converter"
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.20.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.20.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ES",
        "description": "Added three new API calls to expose Amazon Elasticsearch imposed limits."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.21.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.21.0.json
@@ -1,27 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DynamoDB",
        "description": "Time to Live (TTL) is a feature that allows you to define when items in a table expire and can be purged from the database, so that you don't have to track expired data and delete it manually. With TTL enabled on a DynamoDB table, you can set a timestamp for deletion on a per-item basis, allowing you to limit storage usage to only those records that are relevant."
    },
    {
        "type": "feature",
        "category": "DynamoDBStreams",
        "description": "Time to Live (TTL) is a feature that allows you to define when items in a table expire and can be purged from the database, so that you don't have to track expired data and delete it manually. With TTL enabled on a DynamoDB table, you can set a timestamp for deletion on a per-item basis, allowing you to limit storage usage to only those records that are relevant."
    },
    {
        "type": "feature",
        "category": "IAM",
        "description": "This release adds support for AWS Organizations service control policies (SCPs) to SimulatePrincipalPolicy operation. If there are SCPs associated with the simulated user's account, their effect on the result is captured in the OrganizationDecisionDetail element in the EvaluationResult."
    },
    {
        "type": "feature",
        "category": "MechanicalTurkRequester",
        "description": "Amazon Mechanical Turk is a web service that provides an on-demand, scalable, human workforce to complete jobs that humans can do better than computers, for example, recognizing objects in photos."
    },
    {
        "type": "feature",
        "category": "Organizations",
        "description": "AWS Organizations is a web service that enables you to consolidate your multiple AWS accounts into an organization and centrally manage your accounts and their resources."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.22.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.22.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "MechanicalTurkRequester",
        "description": "Rename MechanicalTurkRequester to MTurk"
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.23.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.23.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "Budgets",
        "description": "When creating or editing a budget via the AWS Budgets API you can define notifications that are sent to subscribers when the actual or forecasted value for cost or usage exceeds the notificationThreshold associated with the budget notification object. Starting today, the maximum allowed value for the notificationThreshold was raised from 100 to 300. This change was made to give you more flexibility when setting budget notifications."
    },
    {
        "type": "feature",
        "category": "OpsWorksCM",
        "description": "OpsWorks for Chef Automate has added a new field \"AssociatePublicIpAddress\" to the CreateServer request, \"CloudFormationStackArn\" to the Server model and \"TERMINATED\" server state."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.24.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.24.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "RDS",
        "description": "Add support to using encrypted clusters as cross-region replication masters. Update CopyDBClusterSnapshot API to support encrypted cross region copy of Aurora cluster snapshots."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.25.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.25.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "WorkDocs",
        "description": "Amazon WorkDocs API provides full administrator level access to WorkDocs site resources, allowing developers to integrate their applications to manage WorkDocs users, content and permissions programmatically."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.26.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.26.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "APIGateway",
        "description": "API Gateway has added support for ACM certificates on custom domain names. Both Amazon-issued certificates and uploaded third-part certificates are supported."
    },
    {
        "type": "feature",
        "category": "CloudDirectory",
        "description": "Introduces a new Cloud Directory API that enables you to retrieve all available parent paths for any type of object (a node, leaf node, policy node, and index node) in a hierarchy."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.27.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.27.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "TemporaryCredentials",
        "description": "Ensure master credentials are not expired before using them to refresh temporary credentials"
    },
    {
        "type": "feature",
        "category": "CodeDeploy",
        "description": "Add paginators for Codedeploy"
    },
    {
        "type": "feature",
        "category": "EMR",
        "description": "This release includes support for instance fleets in Amazon EMR"
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.28.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.28.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DeviceFarm",
        "description": "Network shaping allows users to simulate network connections and conditions while testing their Android, iOS, and web apps with AWS Device Farm."
    },
    {
        "type": "feature",
        "category": "CloudWatchEvents",
        "description": "This update extends Target Data Type for configuring Target behavior during invocation."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.29.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.29.0.json
@@ -1,27 +0,0 @@
 [
    {
        "type": "feature",
        "category": "protocol",
        "description": "The SDK can now support JSON-value string shapes in headers"
    },
    {
        "type": "feature",
        "category": "Pinpoint",
        "description": "Added ability to segment endpoints by user attributes in addition to endpoint attributes."
    },
    {
        "type": "feature",
        "category": "Pinpoint",
        "description": "Added functionality to publish raw app analytics and campaign events data as events streams to Kinesis and Kinesis Firehose."
    },
    {
        "type": "feature",
        "category": "ELBv2",
        "description": "Adding waiters for LoadBalancers in ELBv2."
    },
    {
        "type": "feature",
        "category": "MarketplaceCommerceAnalytics",
        "description": "This update adds a new data set, us_sales_and_use_tax_records, which enables AWS Marketplace sellers to programmatically access to their U.S. Sales and Use Tax report data."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.30.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.30.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DynamoDb",
        "description": "Allow objects with inheritance chains to be converted to MapAttributeValues instead of undefined"
    },
    {
        "type": "bugfix",
        "category": "CredentialsError",
        "description": "Update AWS.Config.getCredentials to overwrite the name (in addition to message and code) of errors thrown by underlying credential providers."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.31.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.31.0.json
@@ -1,27 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DynamoDB",
        "description": "Adds ability to customize retry delays for DynamoDB. This previously worked for all services except DynamoDB. Also adds jitter to DynamoDB retries. See `AWS.Config.retryDelayOptions` for more information."
    },
    {
        "type": "feature",
        "category": "Waiter",
        "description": "Allow customization of a waiter using a special `$waiter` key"
    },
    {
        "type": "feature",
        "category": "Lambda",
        "description": "Adds support for new runtime Node.js v6.10 for AWS Lambda service. :tada:"
    },
    {
        "type": "feature",
        "category": "ELBv2",
        "description": "Adding waiters for Elastic Load Balancing V2"
    },
    {
        "type": "feature",
        "category": "Discovery",
        "description": "Adds export configuration options to the API."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.32.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.32.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "S3",
        "description": "Adds a means of specifying tags to apply to objects of any size uploaded with AWS.S3.ManagedUploader"
    },
    {
        "type": "feature",
        "category": "ApplicationAutoScaling",
        "description": "Application AutoScaling is launching support for a new target resource (AppStream 2.0 Fleets) as a scalable target."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.33.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.33.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "core",
        "description": "Adds support for 'v4' and 'v4-unsigned-body' authtype traits."
    },
    {
        "type": "bugfix",
        "category": "ManagedUpload",
        "description": "Ensures multi-part upload locations are URI-decoded to match single-part upload locations."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.34.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.34.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "features",
        "category": "Batch",
        "description": "Customers can now provide a retryStrategy as part of the RegisterJobDefinition and SubmitJob API calls."
    },
    {
        "type": "features",
        "category": "EC2",
        "description": "Customers can now tag their Amazon EC2 Instances and Amazon EBS Volumes at the time of their creation."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.35.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.35.0.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFormation",
        "description": "Adding paginators for ListExports and ListImports"
    },
    {
        "type": "feature",
        "category": "CloudFront",
        "description": "Amazon CloudFront now supports user configurable HTTP Read and Keep-Alive Idle Timeouts for your Custom Origin Servers"
    },
    {
        "type": "feature",
        "category": "ResourceGroupsTaggingAPI",
        "description": "Resource Groups Tagging APIs can help you organize your resources and enable you to simplify resource management, access management, and cost allocation."
    },
    {
        "type": "feature",
        "category": "StorageGateway",
        "description": "File gateway mode in AWS Storage gateway provides access to objects in S3 as files on a Network File System (NFS) mount point. Once a file share is created, any changes made externally to the S3 bucket will not be reflected by the gateway. Using the cache refresh feature in this update, the customer can trigger an on-demand scan of the keys in their S3 bucket and refresh the file namespace cached on the gateway. It takes as an input the fileShare ARN and refreshes the cache for only that file share. Additionally there is new functionality on file gateway that allows you configure what squash options they would like on their file share, this allows a customer to configure their gateway to not squash root permissions. This can be done by setting options in NfsOptions for CreateNfsFileShare and UpdateNfsFileShare APIs."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.36.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.36.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudDirectory",
        "description": "ListObjectAttributes now supports filtering by facet."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.37.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.37.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "LexRuntime",
        "description": "Adds support to PostContent for speech input"
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.38.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.38.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudWatch",
        "description": "Amazon Web Services announced the immediate availability of two additional alarm configuration rules for Amazon CloudWatch Alarms. The first rule is for configuring missing data treatment. Customers have the options to treat missing data as alarm threshold breached, alarm threshold not breached, maintain alarm state and the current default treatment. The second rule is for alarms based on percentiles metrics that can trigger unnecassarily if the percentile is calculated from a small number of samples. The new rule can treat percentiles with low sample counts as same as missing data. If the first rule is enabled, the same treatment will be applied when an alarm encounters a percentile with low sample counts."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.39.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.39.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ElastiCache",
        "description": "ElastiCache added support for testing the Elasticache Multi-AZ feature with Automatic Failover."
    },
    {
        "type": "feature",
        "category": "Http",
        "description": "Adds a connectTimeout option that allows slow-to-establish socket connections to be quickly abandoned"
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.4.10.json
+++ b/src/node_modules/aws-sdk/.changes/2.4.10.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "util",
        "description": "Parse ini files containing comments using #"
    },
    {
        "type": "feature",
        "category": "Iot",
        "description": "Adds support for thing types. Thing types are entities that store a description of common features of Things that are of the same logical type. Also adds support for `:` in Thing name. Adds a separator in Firehose action."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.4.11.json
+++ b/src/node_modules/aws-sdk/.changes/2.4.11.json
@@ -1,32 +0,0 @@
 [
    {
        "type": "feature",
        "category": "APIGateway",
        "description": "Adds support for authentication through Cognito User Pools."
    },
    {
        "type": "feature",
        "category": "CognitoIdentityServiceProvider",
        "description": "Introduces support for Your User Pools."
    },
    {
        "type": "feature",
        "category": "DirectoryService",
        "description": "Enables routing to on-premises public IP for Microsoft Active Directory."
    },
    {
        "type": "feature",
        "category": "EC2",
        "description": "Enables resolution of DNS queries from a peered VPC to a private IP address."
    },
    {
        "type": "feature",
        "category": "ES",
        "description": "Updates to Elasticsearch version 2.3, which offers improved performance, memory management, and security. It also offers several new features includinng pipeline aggregations to perform advanced analytics like moving averages and derivatives, and enhancements to geospatial queries."
    },
    {
        "type": "feature",
        "category": "Waiter",
        "description": "Adds Waiters for AWS.CodeDeploy."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.4.12.json
+++ b/src/node_modules/aws-sdk/.changes/2.4.12.json
@@ -1,42 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "Request",
        "description": "Adds a content-length check for the stream returned from `createReadStream()`, and the stream will emit an error when the bytes received are fewer than specified by the response content-length header."
    },
    {
        "type": "bugfix",
        "category": "S3",
        "description": "Reverts behavior introduced in version `2.4.0` of the SDK to default the `signatureVersion` of S3 clients to `v4`. S3 clients instantiated without a user-defined `signatureVersion` will now default to `v2` unless the region only supports `v4` signing. This change is being made due to issues sending non-ascii characters in headers when using `v4` signing."
    },
    {
        "type": "feature",
        "category": "CloudWatchLogs",
        "description": "Updates the `putMetricFilter` operation."
    },
    {
        "type": "feature",
        "category": "EMR",
        "description": "Adds enhanced debugging."
    },
    {
        "type": "feature",
        "category": "Iot",
        "description": "Adds `listOutgoingCertificates` and support for allowing autoregistration."
    },
    {
        "type": "feature",
        "category": "MachineLearning",
        "description": "Adds compute time and entity timestamp to multiple operations."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "Support for license model and versioning of option groups."
    },
    {
        "type": "feature",
        "category": "Route53Domains",
        "description": "Adds new APIs to renew domains for a specified duration, get domain suggestions, and view billing."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.4.13.json
+++ b/src/node_modules/aws-sdk/.changes/2.4.13.json
@@ -1,27 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ApplicationAutoScaling",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "AutoScaling",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "CodeDeploy",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "GameLift",
        "description": "Provides a new Search API for GameLift, which allows game developers to retrieve filtered and sorted lists of their GameSessions."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "You can now use the AWS Management Console to easily move your DB instance to a different VPC, or to a different subnet group in the same VPC. For more information, see Updating the VPC for a DB Instance. If your DB instance is not in a VPC, you can now use the AWS Management Console to easily move your DB instance into a VPC. You can now copy the source files from a MySQL database to an Amazon Simple Storage Service (Amazon S3) bucket, and then restore an Amazon Aurora DB cluster from those files. This option can be considerably faster than migrating data using mysqldump."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.4.14.json
+++ b/src/node_modules/aws-sdk/.changes/2.4.14.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFront",
        "description": "Amazon CloudFront now supports tagging for Web and Streaming distributions. Tags make it easier for you to allocate costs and optimize spending by categorizing and grouping AWS resources."
    },
    {
        "type": "feature",
        "category": "ECR",
        "description": "Adds filtering of ListImages requests based on whether an image is tagged or untagged."
    },
    {
        "type": "feature",
        "category": "MarketplaceCommerceAnalytics",
        "description": "Adds the `startSupportDataExport` operation."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.4.8.json
+++ b/src/node_modules/aws-sdk/.changes/2.4.8.json
@@ -1,42 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFormation",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "CloudHSM",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "DeviceFarm",
        "description": "Adds session-based APIs."
    },
    {
        "type": "feature",
        "category": "EMR",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "ElastiCache",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "ElasticBeanstalk",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "Redshift",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "SSM",
        "description": "Adds notification support."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.4.9.json
+++ b/src/node_modules/aws-sdk/.changes/2.4.9.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ACM",
        "description": "Adds reason for failure when describing certificates."
    },
    {
        "type": "feature",
        "category": "ConfigService",
        "description": "Adds support for RDS and ACM resources types and introduces two new APIs: DeleteEvaluationResults and StartConfigRulesEvaluation. Updated PutConfigRule API can now create Config rules that are triggered by both configuration changes and periodicity."
    },
    {
        "type": "feature",
        "category": "ElasticTranscoder",
        "description": "Adds WAV file format output support."
    },
    {
        "type": "feature",
        "category": "Paginator",
        "description": "Adds paginator for SSM DescribeInstanceInformation operation."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.40.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.40.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "Redshift",
        "description": "This update adds the GetClusterCredentials API which is used to get temporary login credentials to the cluster. AccountWithRestoreAccess now has a new member AccountAlias, this is the identifier of the AWS support account authorized to restore the specified snapshot. This is added to support the feature where the customer can share their snapshot with the Amazon Redshift Support Account without having to manually specify the AWS Redshift Service account ID on the AWS Console/API."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.41.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.41.0.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "feature",
        "category": "APIGateway",
        "description": "API Gateway request validators"
    },
    {
        "type": "feature",
        "category": "Batch",
        "description": "API Update for AWS Batch: Customer provided AMI for MANAGED Compute Environment "
    },
    {
        "type": "feature",
        "category": "GameLift",
        "description": "Allows developers to utilize an improved workflow when calling our Queues API and introduces a new feature that allows developers to specify a maximum allowable latency per Queue."
    },
    {
        "type": "feature",
        "category": "OpsWorks",
        "description": "Cloudwatch Logs agent configuration can now be attached to OpsWorks Layers using CreateLayer and UpdateLayer. OpsWorks will then automatically install and manage the CloudWatch Logs agent on the instances part of the OpsWorks Layer."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.42.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.42.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "Parser",
        "description": "Makes casting payload blobs to strings an exceptional behavior rather than the default"
    },
    {
        "type": "feature",
        "category": "Lambda",
        "description": "You can use tags to group and filter your Lambda functions, making it easier to analyze them for billing allocation purposes. For more information, see Tagging Lambda Functions.  You can now write or upgrade your Lambda functions using Python version 3.6. For more information, see Programming Model for Authoring Lambda Functions in Python. Note: Features will be rolled out in the US regions on 4/19."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.43.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.43.0.json
@@ -1,42 +0,0 @@
 [
    {
        "type": "feature",
        "category": "APIGateway",
        "description": "Add support for \"embed\" property."
    },
    {
        "type": "feature",
        "category": "CodeStar",
        "description": "AWS CodeStar is a cloud-based service for creating, managing, and working with software development projects on AWS. An AWS CodeStar project creates and integrates AWS services for your project development toolchain. AWS CodeStar also manages the permissions required for project users."
    },
    {
        "type": "feature",
        "category": "EC2",
        "description": "Adds support for creating an Amazon FPGA Image (AFI) from a specified design checkpoint (DCP)."
    },
    {
        "type": "feature",
        "category": "IAM",
        "description": "This changes introduces a new IAM role type, Service Linked Role, which works like a normal role but must be managed via services' control. "
    },
    {
        "type": "feature",
        "category": "Lambda",
        "description": "Lambda integration with CloudDebugger service to enable customers to enable tracing for the Lambda functions and send trace information to the CloudDebugger service."
    },
    {
        "type": "feature",
        "category": "LexModelBuildingService",
        "description": "Amazon Lex is a service for building conversational interfaces into any application using voice and text."
    },
    {
        "type": "feature",
        "category": "Polly",
        "description": "API Update for Amazon Polly: Add support for speech marks"
    },
    {
        "type": "feature",
        "category": "Rekognition",
        "description": "Given an image, the API detects explicit or suggestive adult content in the image and returns a list of corresponding labels with confidence scores, as well as a taxonomy (parent-child relation) for each label."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.44.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.44.0.json
@@ -1,32 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DeviceFarm",
        "description": "API Update for AWS Device Farm: Support for Deals and Promotions "
    },
    {
        "type": "feature",
        "category": "ELBv2",
        "description": "Adding LoadBalancersDeleted waiter for Elasticloadbalancingv2"
    },
    {
        "type": "feature",
        "category": "EnvironmentVariable",
        "description": "Load config from ~/.aws/config if AWS_SDK_LOAD_CONFIG is set"
    },
    {
        "type": "feature",
        "category": "EnvironmentVariable",
        "description": "Add support for specifying the location of the shared config file via the AWS_CONFIG_FILE environment variable. This variable is only honored if AWS_SDK_LOAD_CONFIG is set to a truthy value."
    },
    {
        "type": "feature",
        "category": "EnvironmentVariable",
        "description": "Add support for the AWS_SHARED_CREDENTIALS_FILE environment variable if AWS_SDK_LOAD_CONFIG is set"
    },
    {
        "type": "feature",
        "category": "Promises",
        "description": "Binds response object to the data object with which successful request promises are resolved"
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.45.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.45.0.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "Promise",
        "description": "Fixes an issue introduced in v2.44.0 where payload members on some CloudFront and S3 operations weren't hoisted when using promises. This issue was introduced in and could affect users that were accessing fields on a response that weren't documented, but were available for backwards compatibility."
    },
    {
        "type": "bugfix",
        "category": "Request",
        "description": "Make `$response` property of resolved promise value non-enumerable to prevent serialization errors"
    },
    {
        "type": "feature",
        "category": "AppStream",
        "description": "The new feature named \"Default Internet Access\" will enable Internet access from AppStream 2.0 instances - image builders and fleet instances. Admins will check a flag either through AWS management console for AppStream 2.0 or through API while creating an image builder or while creating/updating a fleet."
    },
    {
        "type": "feature",
        "category": "Kinesis",
        "description": "Adds a new waiter, StreamNotExists, to Kinesis."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.46.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.46.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "SharedIniFileCredentials",
        "description": "This fix reverts a regression introduced in version 2.44.0 in which the value returned by os.homedir would be used in preference over the value of the HOME environment variable"
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "With Amazon Relational Database Service (Amazon RDS) running MySQL or Amazon Aurora, you can now authenticate to your DB instance using IAM database authentication."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "Adds AWS.RDS.Signer class to generate auth tokens for connecting to a database."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.47.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.47.0.json
@@ -1,32 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFormation",
        "description": "API update for CloudFormation: New optional parameter ClientRequestToken which can be used as an idempotency token to safely retry certain operations as well as tagging StackEvents."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "The DescribeDBClusterSnapshots API now returns a SourceDBClusterSnapshotArn field which identifies the source DB cluster snapshot of a copied snapshot."
    },
    {
        "type": "feature",
        "category": "React Native",
        "description": "Adds support for running the SDK in React Native. See the README for instructions."
    },
    {
        "type": "feature",
        "category": "Rekognition",
        "description": "Fix for missing file type check"
    },
    {
        "type": "feature",
        "category": "SQS",
        "description": "Adding server-side encryption (SSE) support to SQS by integrating with AWS KMS; adding new queue attributes to SQS CreateQueue, SetQueueAttributes and GetQueueAttributes APIs to support SSE."
    },
    {
        "type": "feature",
        "category": "Snowball",
        "description": "The Snowball API has a new exception that can be thrown for list operation requests."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.48.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.48.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFormation",
        "description": "Adding back the removed waiters and paginators."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.49.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.49.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ECS",
        "description": "Exposes container instance registration time in ECS:DescribeContainerInstances."
    },
    {
        "type": "feature",
        "category": "Lambda",
        "description": "Support for UpdateFunctionCode DryRun option"
    },
    {
        "type": "feature",
        "category": "MarketplaceEntitlementService",
        "description": "AWS Marketplace Entitlement Service enables AWS Marketplace sellers to determine the capacity purchased by their customers."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.5.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.5.0.json
@@ -1,37 +0,0 @@
 [
    {
        "type": "feature",
        "category": "AutoScaling",
        "description": "Adds 3 new APIs for ELB L7 integration: attachLoadBalancerTargetGroups, detachLoadBalancerTargetGroups, and describeLoadBalancerTargetGroups."
    },
    {
        "type": "feature",
        "category": "ECS",
        "description": "Adds ECS support for ELBv2. Supports Application Load Balancer target groups to enable dynamic ports and path-based routing."
    },
    {
        "type": "feature",
        "category": "ELBv2",
        "description": "Adds new backwards incompatible application load balancer API version.  Application load balancers are a new load balancer that is now supported by the Elastic Load Balancing service. Application load balancers support HTTP/2, WebSockets, routing based on URL path, and routing to multiple ports on a single instance."
    },
    {
        "type": "feature",
        "category": "KMS",
        "description": "Adds support for importing customer-supplied cryptographic keys. New import key feature lets you import keys from your own key management infrastructure to KMS for greater control over generation and storage of keys and meeting compliance requirements of sensitive workloads."
    },
    {
        "type": "feature",
        "category": "KinesisAnalytics",
        "description": "Adds the new service Amazon Kinesis Analytics, a fully managed service for continuously querying streaming data using standard SQL. With Kinesis Analytics, you can write standard SQL queries on streaming data and gain actionable insights in real-time, without having to learn any new programming skills. The service allows you to build applications that continuously read data from streaming data sources, process that data using standard SQL, and send the processed data to up to four destinations of your choice. Kinesis Analytics enables you to generate time-series analytics, feed a real-time dashboard, create real-time alarms and notifications, and much more."
    },
    {
        "type": "feature",
        "category": "S3",
        "description": "Adds support for IPv6/IPv4 Dualstack endpoint. A new opt-in boolean  option `use Dualstack` can be specified for S3 service clients: `new AWS.S3({useDualstack: true})`. Alternatively, to configure it once for all subsequent S3 service clients: `AWS.config.update({s3: {useDualstack: true}})`."
    },
    {
        "type": "feature",
        "category": "Snowball",
        "description": "Adds Amazon Snowball, a new job management service."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.5.1.json
+++ b/src/node_modules/aws-sdk/.changes/2.5.1.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ACM",
        "description": "Increase tagging limit from 10 to 50."
    },
    {
        "type": "feature",
        "category": "APIGateway",
        "description": "Amazon API Gateway now supports API usage plans. Usage plans allows you to easily manage and monetize your APIs for your API-based business."
    },
    {
        "type": "feature",
        "category": "ECS",
        "description": "Adds support for memory reservation and network mode on task definitions. Also adds splunk as a supported log driver."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.5.2.json
+++ b/src/node_modules/aws-sdk/.changes/2.5.2.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "Waiter",
        "description": "Fixes bug in `clusterDeleted` waiter for AWS.Redshift."
    },
    {
        "type": "feature",
        "category": "EC2",
        "description": "Adds  new APIs supporting dedicated host reservations. Also adds new property to response of `describeSpotFleetRequests` to indicate  the activity status of spot fleet requests."
    },
    {
        "type": "feature",
        "category": "Request",
        "description": "eachItem method stops iteration on returning false (like eachPage)"
    },
    {
        "type": "feature",
        "category": "WorkSpaces",
        "description": "Adds new APIs to support the launch and management of WorkSpaces that are paid for and used by the hour."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.5.3.json
+++ b/src/node_modules/aws-sdk/.changes/2.5.3.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "RDS",
        "description": "Adds resource ARNs to Describe APIs."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.5.4.json
+++ b/src/node_modules/aws-sdk/.changes/2.5.4.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFront",
        "description": "CloudFront is adding a Querystring Whitelist Option. Customers will be able to choose to forward certain querystring keys instead of a.) all of them or b.) none of them."
    },
    {
        "type": "feature",
        "category": "CodePipeline",
        "description": "CodePiepline has introduced a new feature to return pipeline execution details. Execution details consists of source revisions that are running in the pipeline. Customers will be able to tell what source revisions that are running through the stages in pipeline by fetching execution details of each stage."
    },
    {
        "type": "feature",
        "category": "Route53",
        "description": "With this release, Route 53 will support the following new features: support for the NAPTR DNS record type, a new testDNSAnswer API which enables customers to send a test query against a specific name server using spoofed delegation nameserver, resolver, and ECS IPs, and support metric-based health check in ap-south-1 region."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.5.5.json
+++ b/src/node_modules/aws-sdk/.changes/2.5.5.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CognitoIdentityServiceProvider",
        "description": "Adds support for bulk import of users."
    },
    {
        "type": "feature",
        "category": "GameLift",
        "description": "Adds Linux support."
    },
    {
        "type": "feature",
        "category": "Iot",
        "description": "Adds Iot as a default service in the browser distribution of the AWS SDK for JavaScript."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "Adds information in response of describeOptionGroupOptions about options that conflict with each other."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.5.6.json
+++ b/src/node_modules/aws-sdk/.changes/2.5.6.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "RDS",
        "description": "Adds new operation describeSourceRegions to provide list of all the source region names and endpoints for any region. Source regions are the regions where current region can get a replica or copy a snapshot from."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.50.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.50.0.json
@@ -1,32 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "ReactNative",
        "description": "Fixes issue where binary responses were empty in iOS (e.g. s3.getObject)"
    },
    {
        "type": "feature",
        "category": "ELB",
        "description": "Add a new API to allow customers to describe their account limits, such as load balancer limit, target group limit etc."
    },
    {
        "type": "feature",
        "category": "ELBv2",
        "description": "Add a new API to allow customers to describe their account limits, such as load balancer limit, target group limit etc."
    },
    {
        "type": "feature",
        "category": "LexModelBuildingService",
        "description": "Releasing new DeleteBotVersion, DeleteIntentVersion and DeleteSlotTypeVersion APIs."
    },
    {
        "type": "feature",
        "category": "Organizations",
        "description": "AWS Organizations APIs that return an Account object now include the email address associated with the account’s root user."
    },
    {
        "type": "bugfix",
        "category": "Request",
        "description": "Updates node.js request handling to obey socket read timeouts after response headers have been received. Previously timeouts were being ignored once headers were received, sometimes causing connections to hang."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.51.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.51.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "SSM",
        "description": "UpdateAssociation API now supports updating document name and targets of an association. GetAutomationExecution API can return FailureDetails as an optional field to the StepExecution Object, which contains failure type, failure stage as well as other failure related information for a failed step."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.52.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.52.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CodeDeploy",
        "description": "This release introduces the previousRevision field in the responses to the GetDeployment and BatchGetDeployments actions. previousRevision provides information about the application revision that was deployed to the deployment group before the most recent successful deployment.  Also, the fileExistsBehavior parameter has been added for CreateDeployment action requests. In the past, if the AWS CodeDeploy agent detected files in a target location that weren't part of the application revision from the most recent successful deployment, it would fail the current deployment by default. This new parameter provides options for how the agent handles these files: fail the deployment, retain the content, or overwrite the content."
    },
    {
        "type": "feature",
        "category": "GameLift",
        "description": "Allow developers to specify how metrics are grouped in CloudWatch for their GameLift fleets. Developers can also specify how many concurrent game sessions activate on a per-instance basis."
    },
    {
        "type": "feature",
        "category": "Inspector",
        "description": "Adds ability to produce an assessment report that includes detailed and comprehensive results of a specified assessment run."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.53.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.53.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "Polly",
        "description": "Amazon Polly adds new German voice \"Vicki\""
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.54.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.54.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "Athena",
        "description": "This release adds support for Amazon Athena. Amazon Athena is an interactive query service that makes it easy to analyze data in Amazon S3 using standard SQL. Athena is serverless, so there is no infrastructure to manage, and you pay only for the queries that you run."
    },
    {
        "type": "feature",
        "category": "Lightsail",
        "description": "This release adds new APIs that make it easier to set network port configurations on Lightsail instances. Developers can now make a single request to both open and close public ports on an instance using the PutInstancePublicPorts operation."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.55.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.55.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "ReactNative",
        "description": "Requests will always have a Content-Type header if they also have a body. Works around an issue caused by React Native's Android XMLHttpRequest implementation that requires the Content-Type header to be present if there is a request body."
    },
    {
        "type": "feature",
        "category": "ResourceGroupsTaggingAPI",
        "description": "You can now specify the number of resources returned per page in GetResources operation, as an optional parameter, to easily manage the list of resources returned by your queries."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.56.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.56.0.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DMS",
        "description": "This release adds support for using Amazon S3 and Amazon DynamoDB as targets for database migration, and using MongoDB as a source for database migration. For more information, see the AWS Database Migration Service documentation."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.57.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.57.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "IAM",
        "description": "The unique ID and access key lengths were extended from 32 to 128"
    },
    {
        "type": "feature",
        "category": "STS",
        "description": "The unique ID and access key lengths were extended from 32 to 128."
    },
    {
        "type": "feature",
        "category": "StorageGateway",
        "description": "Two Storage Gateway data types, Tape and TapeArchive, each have a new response element, TapeUsedInBytes. This element helps you manage your virtual tapes. By using TapeUsedInBytes, you can see the amount of data written to each virtual tape."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.58.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.58.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "AppStream",
        "description": "Support added for persistent user storage, backed by S3."
    },
    {
        "type": "feature",
        "category": "Rekognition",
        "description": "Updated the CompareFaces API response to include orientation information, unmatched faces, landmarks, pose, and quality of the compared faces."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.59.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.59.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "S3",
        "description": "Update ManagedUploader body verification to allow empty strings"
    },
    {
        "type": "feature",
        "category": "CloudDirectory",
        "description": "Cloud Directory has launched support for Typed Links, enabling customers to create object-to-object relationships that are not hierarchical in nature. Typed Links enable customers to quickly query for data along these relationships. Customers can also enforce referential integrity using Typed Links, ensuring data in use is not inadvertently deleted."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.0.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFront",
        "description": "Adds HTTP2 support for Amazon CloudFront distributions."
    },
    {
        "type": "feature",
        "category": "MetadataService",
        "description": "Adds retry logic to the EC2 Metadata Service, so that EC2MetadataCredentials will retry TimeoutError. This retry logic is also added to ECSCredentials. Resolves #692"
    },
    {
        "type": "feature",
        "category": "ServiceCatalog",
        "description": "CORS support added. Now a default service in the browser build of the JavaScript SDK."
    },
    {
        "type": "feature",
        "category": "Tools",
        "description": "Adds support for bundling the SDK with webpack. Also adds support for creating node.js bundles using webpack or browserify."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.1.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.1.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "SDK",
        "description": "Fixes an issue that caused all services to be loaded into memory when requiring the SDK. This issue was introduced in version `2.6.0` of the SDK, and address #1124."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.10.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.10.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFront",
        "description": "Ability to use Amazon CloudFront to deliver your content both via IPv6 and IPv4 using HTTP/HTTPS."
    },
    {
        "type": "feature",
        "category": "IoT",
        "description": "Updates IoT API to the latest available version."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "Updates RDS to support accessing other AWS services by gassociating an IAM role with necessary permissions to your DB cluster."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.11.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.11.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "Budgets",
        "description": "Adds the AWS Budgets service API via AWS.Budgets."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.12.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.12.json
@@ -1,22 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CredentialProviderChain",
        "description": "Adds promise support for the `resolve` method on the AWS.CredentialProviderChain class. Corresponding promise method is called `resolvePromise`."
    },
    {
        "type": "feature",
        "category": "Credentials",
        "description": "Adds promise support for the `get` and `refresh` methods of the AWS.Credentials class. Corresponding promise methods are called `getPromise` and `refreshPromise`."
    },
    {
        "type": "feature",
        "category": "ManagedUpload",
        "description": "Adds promise support for S3.ManagedUpload. Calling `s3.upload(params).promise()` will return a promise."
    },
    {
        "type": "feature",
        "category": "SMS",
        "description": "AWS Server Migration Service (SMS) is an agentless service which makes it easier and faster for you to migrate thousands of on-premises workloads to AWS. AWS SMS allows you to automate, schedule, and track incremental replications of live server volumes, making it easier for you to coordinate large-scale server migrations."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.13.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.13.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CloudFormation",
        "description": "Adding ResourcesToSkip parameter to ContinueUpdateRollback API, adding support for ListExports, new ChangeSet types and Transforms."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.14.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.14.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "SES",
        "description": "Amazon Simple Email Service (Amazon SES) now enables you to track your bounce, complaint, delivery, sent, and rejected email metrics with fine-grained granularity."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.15.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.15.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "DirectConnect",
        "description": "AWS Direct Connect provides three new APIs to support basic tagging on Direct Connect resources."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.2.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.2.json
@@ -1,7 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ServiceCatalog",
        "description": "Updates the API for AWS.ServiceCatalog."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.3.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.3.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "Node_Https",
        "description": "Fixes an issue caused when https.globalAgent is set to false."
    },
    {
        "type": "feature",
        "category": "Iot",
        "description": "Updates registerCertificate operation, and allows users to specify cannedAcl for S3 action."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "Updates describeDbCluster operation to allow specifying a ReaderEndpoint for accessing cluster readers."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.4.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.4.json
@@ -1,32 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "Browser",
        "description": "Updates `url` and `querystring` dependencies to be controlled by the SDK instead of tools like browserify or webpack."
    },
    {
        "type": "bugfix",
        "category": "Config",
        "description": "Fixes an issue where specifying service-specific config on the global AWS.config object would fail if the service had not yet been instantiated."
    },
    {
        "type": "feature",
        "category": "CodeDeploy",
        "description": "AWS CodeDeploy now integrates with Amazon CloudWatch alarms, making it possible to stop a deployment if there is a change in the state of a specified alarm for a number of consecutive periods, as specified in the alarm threshold. AWS CodeDeploy also now supports automatically rolling back a deployment if certain conditions are met, such as a deployment failure or an activated alarm."
    },
    {
        "type": "feature",
        "category": "EMR",
        "description": "Added support for Security Configurations which can be used to enable encryption at-rest and in-transit for certain applications on Amazon EMR."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "Provide local time zone support for AWS RDS SqlServer database instances."
    },
    {
        "type": "feature",
        "category": "Redshift",
        "description": "This release of Amazon Redshift introduces Enhanced VPC Routing. When you use Amazon Redshift Enhanced VPC Routing, Amazon Redshift forces all COPY and UNLOAD traffic between your cluster and your data repositories through your Amazon VPC."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.5.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.5.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "apiVersion",
        "description": "Fixes an issue where some service clients would fail to instantiate if an older apiVersion was specified."
    },
    {
        "type": "feature",
        "category": "CloudFormation",
        "description": "Adds support for specifying an IAM service role for CloudFormation stack operations."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.6.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.6.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "EC2",
        "description": "Adding support for EC2 Convertible RIs and the EC2 RI regional benefit."
    },
    {
        "type": "feature",
        "category": "S3",
        "description": "S3 API update with partNumber extension and a bug fix to address list-objects command failing when a bucket is marked with request-pays."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.7.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.7.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CognitoIdentityServiceProvider",
        "description": "Added new operation \"AdminCreateUser\" that creates a new user in the specified user pool and sends a welcome message via email or phone (SMS)."
    },
    {
        "type": "feature",
        "category": "Route53",
        "description": "Retries PriorRequestNotComplete errors."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.8.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.8.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "ECR",
        "description": "DescribeImages is a new api used to expose image metadata which today includes image size and image creation timestamp."
    },
    {
        "type": "feature",
        "category": "ElastiCache",
        "description": "Elasticache is launching a new major engine release of Redis, 3.2 (providing stability updates and new command sets over 2.8), as well as ElasticSupport for enabling Redis Cluster in 3.2, which provides support for multiple node groups to horizontally scale data, as well as superior engine failover capabilities."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.6.9.json
+++ b/src/node_modules/aws-sdk/.changes/2.6.9.json
@@ -1,27 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "s3",
        "description": "Propagate an error from a stream to s3.upload callback #1169"
    },
    {
        "type": "feature",
        "category": "S3",
        "description": "Adds support for using dualstack with accelerate endpoints."
    },
    {
        "type": "feature",
        "category": "ACM",
        "description": "This change allows users to import third-party SSL/TLS certificates into ACM."
    },
    {
        "type": "feature",
        "category": "ElasticBeanstalk",
        "description": "Adds CodeCommit integraion. DescribeApplicationVersions updated to support pagination."
    },
    {
        "type": "feature",
        "category": "GameLift",
        "description": "New APIs to protect game developer resource (builds, alias, fleets, instances, game sessions and player sessions) against abuse."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.60.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.60.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "bugfix",
        "category": "Core",
        "description": "Fixes issue where some TimeStamp shapes had an incorrect timestampFormat. Specifically affects S3.putBucketLifecycleConfiguration when using Date fields."
    },
    {
        "type": "feature",
        "category": "RDS",
        "description": "Amazon RDS customers can now easily and quickly stop and start their DB instances."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.61.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.61.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "CodeDeploy",
        "description": "AWS CodeDeploy has improved how it manages connections to GitHub accounts and repositories. You can now create and store up to 25 connections to GitHub accounts in order to associate AWS CodeDeploy applications with GitHub repositories. Each connection can support multiple repositories. You can create connections to up to 25 different GitHub accounts, or create more than one connection to a single account. The ListGitHubAccountTokenNames command has been introduced to retrieve the names of stored connections to GitHub accounts that you have created. The name of the connection to GitHub used for an AWS CodeDeploy application is also included in the ApplicationInfo structure.  Two new fields, lastAttemptedDeployment and lastSuccessfulDeployment, have been added to DeploymentGroupInfo to improve the handling of deployment group information in the AWS CodeDeploy console. Information about these latest deployments can also be retrieved using the GetDeploymentGroup and BatchGetDeployment group requests. Also includes a region update  (us-gov-west-1)."
    },
    {
        "type": "feature",
        "category": "CognitoIdentityServiceProvider",
        "description": "Added support within Amazon Cognito User Pools for 1) a customizable hosted UI for user sign up and sign in and 2) integration of external identity providers."
    },
    {
        "type": "feature",
        "category": "ELBv2",
        "description": "Update the existing DescribeRules API to support pagination."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.62.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.62.0.json
@@ -1,12 +0,0 @@
 [
    {
        "type": "feature",
        "category": "KinesisAnalytics",
        "description": "Kinesis Analytics publishes error messages CloudWatch logs in case of application misconfigurations"
    },
    {
        "type": "feature",
        "category": "WorkDocs",
        "description": "This release includes new APIs to manage tags and custom metadata on resources and also new APIs to add and retrieve comments at the document level."
    }
 ]
--- a/src/node_modules/aws-sdk/.changes/2.63.0.json
+++ b/src/node_modules/aws-sdk/.changes/2.63.0.json
@@ -1,17 +0,0 @@
 [
    {
        "type": "feature",
        "category": "AppStream",
        "description": "AppStream 2.0 Custom Security Groups allows you to easily control what network resources your streaming instances and images have access to. You can assign up to 5 security groups per Fleet to control the inbound and outbound network access to your streaming instances to specific IP ranges, network protocols, or ports."
    },
    {
        "type": "feature",
        "category": "AutoScaling",
        "description": "Autoscaling resource model update."
    },
    {
        "type": "feature",
        "category": "Iot",
        "description": " Added Salesforce action to IoT Rules Engine."
    }
 ]