diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,367 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,45 @@ +# Amazon Lex Runtime Service SDK + +* [Version](#version) +* [Description](#description) +* [Contribute](#contribute) +* [Licence](#licence) + + +## Version + +`1.5.0` + + +## Description + +Documentation is available via [Hackage](http://hackage.haskell.org/package/amazonka-lex-runtime) +and the [AWS API Reference](https://aws.amazon.com/documentation/). + +The types from this library are intended to be used with [amazonka](http://hackage.haskell.org/package/amazonka), +which provides mechanisms for specifying AuthN/AuthZ information, sending requests, +and receiving responses. + +Lenses are used for constructing and manipulating types, +due to the depth of nesting of AWS types and transparency regarding +de/serialisation into more palatable Haskell values. +The provided lenses should be compatible with any of the major lens libraries +[lens](http://hackage.haskell.org/package/lens) or [lens-family-core](http://hackage.haskell.org/package/lens-family-core). + +See [Network.AWS.LexRuntime](http://hackage.haskell.org/package/amazonka-lex-runtime/docs/Network-AWS-LexRuntime.html) +or [the AWS documentation](https://aws.amazon.com/documentation/) to get started. + + +## Contribute + +For any problems, comments, or feedback please create an issue [here on GitHub](https://github.com/brendanhay/amazonka/issues). + +> _Note:_ this library is an auto-generated Haskell package. Please see `amazonka-gen` for more information. + + +## Licence + +`amazonka-lex-runtime` is released under the [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/). + +Parts of the code are derived from AWS service descriptions, licensed under Apache 2.0. +Source files subject to this contain an additional licensing clause in their header. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/amazonka-lex-runtime.cabal b/amazonka-lex-runtime.cabal new file mode 100644 --- /dev/null +++ b/amazonka-lex-runtime.cabal @@ -0,0 +1,87 @@ +name: amazonka-lex-runtime +version: 1.5.0 +synopsis: Amazon Lex Runtime Service SDK. +homepage: https://github.com/brendanhay/amazonka +bug-reports: https://github.com/brendanhay/amazonka/issues +license: MPL-2.0 +license-file: LICENSE +author: Brendan Hay +maintainer: Brendan Hay +copyright: Copyright (c) 2013-2017 Brendan Hay +category: Network, AWS, Cloud, Distributed Computing +build-type: Simple +cabal-version: >= 1.10 +extra-source-files: README.md fixture/*.yaml fixture/*.proto src/.gitkeep +description: + The types from this library are intended to be used with + , which provides + mechanisms for specifying AuthN/AuthZ information, sending requests, + and receiving responses. + . + Lenses are used for constructing and manipulating types, + due to the depth of nesting of AWS types and transparency regarding + de/serialisation into more palatable Haskell values. + The provided lenses should be compatible with any of the major lens libraries + such as or + . + . + See "Network.AWS.LexRuntime" or + to get started. + +source-repository head + type: git + location: git://github.com/brendanhay/amazonka.git + subdir: amazonka-lex-runtime + +library + default-language: Haskell2010 + hs-source-dirs: src gen + + ghc-options: + -Wall + -fwarn-incomplete-uni-patterns + -fwarn-incomplete-record-updates + -funbox-strict-fields + + exposed-modules: + Network.AWS.LexRuntime + , Network.AWS.LexRuntime.PostContent + , Network.AWS.LexRuntime.PostText + , Network.AWS.LexRuntime.Types + , Network.AWS.LexRuntime.Waiters + + other-modules: + Network.AWS.LexRuntime.Types.Product + , Network.AWS.LexRuntime.Types.Sum + + build-depends: + amazonka-core == 1.5.0.* + , base >= 4.7 && < 5 + +test-suite amazonka-lex-runtime-test + type: exitcode-stdio-1.0 + default-language: Haskell2010 + hs-source-dirs: test + main-is: Main.hs + + ghc-options: -Wall -threaded + + -- This section is encoded by the template and any modules added by + -- hand outside these namespaces will not correctly be added to the + -- distribution package. + other-modules: + Test.AWS.LexRuntime + , Test.AWS.Gen.LexRuntime + , Test.AWS.LexRuntime.Internal + + build-depends: + amazonka-core == 1.5.0.* + , amazonka-test == 1.5.0.* + , amazonka-lex-runtime + , base + , bytestring + , tasty + , tasty-hunit + , text + , time + , unordered-containers diff --git a/fixture/PostContent.yaml b/fixture/PostContent.yaml new file mode 100644 --- /dev/null +++ b/fixture/PostContent.yaml @@ -0,0 +1,10 @@ +--- +method: POST +headers: + Authorization: AWS4-HMAC-SHA256 Credential=access/20091028/us-east-1/runtime.lex/aws4_request, SignedHeaders=content-type;host;x-amz-content-sha256;x-amz-date, Signature=? + Host: runtime.lex.us-east-1.amazonaws.com + Content-Type: application/x-www-form-urlencoded; charset=utf-8 + X-Amz-Content-SHA256: abcdef + X-Amz-Date: 20091028T223200Z +body: + '' diff --git a/fixture/PostContentResponse.proto b/fixture/PostContentResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/PostContentResponse.proto diff --git a/fixture/PostText.yaml b/fixture/PostText.yaml new file mode 100644 --- /dev/null +++ b/fixture/PostText.yaml @@ -0,0 +1,10 @@ +--- +method: POST +headers: + Authorization: AWS4-HMAC-SHA256 Credential=access/20091028/us-east-1/runtime.lex/aws4_request, SignedHeaders=content-type;host;x-amz-content-sha256;x-amz-date, Signature=? + Host: runtime.lex.us-east-1.amazonaws.com + Content-Type: application/x-www-form-urlencoded; charset=utf-8 + X-Amz-Content-SHA256: abcdef + X-Amz-Date: 20091028T223200Z +body: + '' diff --git a/fixture/PostTextResponse.proto b/fixture/PostTextResponse.proto new file mode 100644 --- /dev/null +++ b/fixture/PostTextResponse.proto diff --git a/gen/Network/AWS/LexRuntime.hs b/gen/Network/AWS/LexRuntime.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/LexRuntime.hs @@ -0,0 +1,134 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.LexRuntime +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Amazon Lex provides both build and runtime endpoints. Each endpoint provides a set of operations (API). Your conversational bot uses the runtime API to understand user utterances (user input text or voice). For example, suppose a user says "I want pizza", your bot sends this input to Amazon Lex using the runtime API. Amazon Lex recognizes that the user request is for the OrderPizza intent (one of the intents defined in the bot). Then Amazon Lex engages in user conversation on behalf of the bot to elicit required information (slot values, such as pizza size and crust type), and then performs fulfillment activity (that you configured when you created the bot). You use the build-time API to create and manage your Amazon Lex bot. For a list of build-time operations, see the build-time API, . +-- +-- +module Network.AWS.LexRuntime + ( + -- * Service Configuration + lexRuntime + + -- * Errors + -- $errors + + -- ** NotAcceptableException + , _NotAcceptableException + + -- ** DependencyFailedException + , _DependencyFailedException + + -- ** UnsupportedMediaTypeException + , _UnsupportedMediaTypeException + + -- ** ConflictException + , _ConflictException + + -- ** NotFoundException + , _NotFoundException + + -- ** RequestTimeoutException + , _RequestTimeoutException + + -- ** LoopDetectedException + , _LoopDetectedException + + -- ** InternalFailureException + , _InternalFailureException + + -- ** BadGatewayException + , _BadGatewayException + + -- ** BadRequestException + , _BadRequestException + + -- ** LimitExceededException + , _LimitExceededException + + -- * Waiters + -- $waiters + + -- * Operations + -- $operations + + -- ** PostText + , module Network.AWS.LexRuntime.PostText + + -- ** PostContent + , module Network.AWS.LexRuntime.PostContent + + -- * Types + + -- ** ContentType + , ContentType (..) + + -- ** DialogState + , DialogState (..) + + -- ** Button + , Button + , button + , bText + , bValue + + -- ** GenericAttachment + , GenericAttachment + , genericAttachment + , gaButtons + , gaSubTitle + , gaImageURL + , gaAttachmentLinkURL + , gaTitle + + -- ** ResponseCard + , ResponseCard + , responseCard + , rcGenericAttachments + , rcVersion + , rcContentType + ) where + +import Network.AWS.LexRuntime.PostContent +import Network.AWS.LexRuntime.PostText +import Network.AWS.LexRuntime.Types +import Network.AWS.LexRuntime.Waiters + +{- $errors +Error matchers are designed for use with the functions provided by +. +This allows catching (and rethrowing) service specific errors returned +by 'LexRuntime'. +-} + +{- $operations +Some AWS operations return results that are incomplete and require subsequent +requests in order to obtain the entire result set. The process of sending +subsequent requests to continue where a previous request left off is called +pagination. For example, the 'ListObjects' operation of Amazon S3 returns up to +1000 objects at a time, and you must send subsequent requests with the +appropriate Marker in order to retrieve the next page of results. + +Operations that have an 'AWSPager' instance can transparently perform subsequent +requests, correctly setting Markers and other request facets to iterate through +the entire result set of a truncated API operation. Operations which support +this have an additional note in the documentation. + +Many operations have the ability to filter results on the server side. See the +individual operation parameters for details. +-} + +{- $waiters +Waiters poll by repeatedly sending a request until some remote success condition +configured by the 'Wait' specification is fulfilled. The 'Wait' specification +determines how many attempts should be made, in addition to delay and retry strategies. +-} diff --git a/gen/Network/AWS/LexRuntime/PostContent.hs b/gen/Network/AWS/LexRuntime/PostContent.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/LexRuntime/PostContent.hs @@ -0,0 +1,318 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.LexRuntime.PostContent +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Sends user input (text or speech) to Amazon Lex. Clients use this API to send text and audio requests to Amazon Lex at runtime. Amazon Lex interprets the user input using the machine learning model that it built for the bot. +-- +-- +-- The @PostContent@ operation supports audio input at 8kHz and 16kHz. You can use 8kHz audio to achieve higher speech recognition accuracy in telephone audio applications. +-- +-- In response, Amazon Lex returns the next message to convey to the user. Consider the following example messages: +-- +-- * For a user input "I would like a pizza," Amazon Lex might return a response with a message eliciting slot data (for example, @PizzaSize@ ): "What size pizza would you like?". +-- +-- * After the user provides all of the pizza order information, Amazon Lex might return a response with a message to get user confirmation: "Order the pizza?". +-- +-- * After the user replies "Yes" to the confirmation prompt, Amazon Lex might return a conclusion statement: "Thank you, your cheese pizza has been ordered.". +-- +-- +-- +-- Not all Amazon Lex messages require a response from the user. For example, conclusion statements do not require a response. Some messages require only a yes or no response. In addition to the @message@ , Amazon Lex provides additional context about the message in the response that you can use to enhance client behavior, such as displaying the appropriate client user interface. Consider the following examples: +-- +-- * If the message is to elicit slot data, Amazon Lex returns the following context information: +-- +-- * @x-amz-lex-dialog-state@ header set to @ElicitSlot@ +-- +-- * @x-amz-lex-intent-name@ header set to the intent name in the current context +-- +-- * @x-amz-lex-slot-to-elicit@ header set to the slot name for which the @message@ is eliciting information +-- +-- * @x-amz-lex-slots@ header set to a map of slots configured for the intent with their current values +-- +-- +-- +-- * If the message is a confirmation prompt, the @x-amz-lex-dialog-state@ header is set to @Confirmation@ and the @x-amz-lex-slot-to-elicit@ header is omitted. +-- +-- * If the message is a clarification prompt configured for the intent, indicating that the user intent is not understood, the @x-amz-dialog-state@ header is set to @ElicitIntent@ and the @x-amz-slot-to-elicit@ header is omitted. +-- +-- +-- +-- In addition, Amazon Lex also returns your application-specific @sessionAttributes@ . For more information, see . +-- +module Network.AWS.LexRuntime.PostContent + ( + -- * Creating a Request + postContent + , PostContent + -- * Request Lenses + , pcAccept + , pcRequestAttributes + , pcSessionAttributes + , pcBotName + , pcBotAlias + , pcUserId + , pcContentType + , pcInputStream + + -- * Destructuring the Response + , postContentResponse + , PostContentResponse + -- * Response Lenses + , pcrsSlots + , pcrsIntentName + , pcrsDialogState + , pcrsInputTranscript + , pcrsMessage + , pcrsSlotToElicit + , pcrsContentType + , pcrsSessionAttributes + , pcrsResponseStatus + , pcrsAudioStream + ) where + +import Network.AWS.Lens +import Network.AWS.LexRuntime.Types +import Network.AWS.LexRuntime.Types.Product +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | /See:/ 'postContent' smart constructor. +data PostContent = PostContent' + { _pcAccept :: !(Maybe Text) + , _pcRequestAttributes :: !(Maybe (Sensitive Text)) + , _pcSessionAttributes :: !(Maybe (Sensitive Text)) + , _pcBotName :: !Text + , _pcBotAlias :: !Text + , _pcUserId :: !Text + , _pcContentType :: !Text + , _pcInputStream :: !HashedBody + } deriving (Show, Generic) + + +-- | Creates a value of 'PostContent' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'pcAccept' - You pass this value as the @Accept@ HTTP header. The message Amazon Lex returns in the response can be either text or speech based on the @Accept@ HTTP header value in the request. * If the value is @text/plain; charset=utf-8@ , Amazon Lex returns text in the response. * If the value begins with @audio/@ , Amazon Lex returns speech in the response. Amazon Lex uses Amazon Polly to generate the speech (using the configuration you specified in the @Accept@ header). For example, if you specify @audio/mpeg@ as the value, Amazon Lex returns speech in the MPEG format. The following are the accepted values: * audio/mpeg * audio/ogg * audio/pcm * text/plain; charset=utf-8 * audio/* (defaults to mpeg) +-- +-- * 'pcRequestAttributes' - You pass this value as the @x-amz-lex-request-attributes@ HTTP header. Request-specific information passed between Amazon Lex and a client application. The value must be a JSON serialized and base64 encoded map with string keys and values. The total size of the @requestAttributes@ and @sessionAttributes@ headers is limited to 12 KB. The namespace @x-amz-lex:@ is reserved for special attributes. Don't create any request attributes with the prefix @x-amz-lex:@ . For more information, see . +-- +-- * 'pcSessionAttributes' - You pass this value as the @x-amz-lex-session-attributes@ HTTP header. Application-specific information passed between Amazon Lex and a client application. The value must be a JSON serialized and base64 encoded map with string keys and values. The total size of the @sessionAttributes@ and @requestAttributes@ headers is limited to 12 KB. For more information, see . +-- +-- * 'pcBotName' - Name of the Amazon Lex bot. +-- +-- * 'pcBotAlias' - Alias of the Amazon Lex bot. +-- +-- * 'pcUserId' - The ID of the client application user. Amazon Lex uses this to identify a user's conversation with your bot. At runtime, each request must contain the @userID@ field. To decide the user ID to use for your application, consider the following factors. * The @userID@ field must not contain any personally identifiable information of the user, for example, name, personal identification numbers, or other end user personal information. * If you want a user to start a conversation on one device and continue on another device, use a user-specific identifier. * If you want the same user to be able to have two independent conversations on two different devices, choose a device-specific identifier. * A user can't have two independent conversations with two different versions of the same bot. For example, a user can't have a conversation with the PROD and BETA versions of the same bot. If you anticipate that a user will need to have conversation with two different versions, for example, while testing, include the bot alias in the user ID to separate the two conversations. +-- +-- * 'pcContentType' - You pass this value as the @Content-Type@ HTTP header. Indicates the audio format or text. The header value must start with one of the following prefixes: * PCM format, audio data must be in little-endian byte order. * audio/l16; rate=16000; channels=1 * audio/x-l16; sample-rate=16000; channel-count=1 * audio/lpcm; sample-rate=8000; sample-size-bits=16; channel-count=1; is-big-endian=false * Opus format * audio/x-cbr-opus-with-preamble; preamble-size=0; bit-rate=256000; frame-size-milliseconds=4 * Text format * text/plain; charset=utf-8 +-- +-- * 'pcInputStream' - User input in PCM or Opus audio format or text format as described in the @Content-Type@ HTTP header. You can stream audio data to Amazon Lex or you can create a local buffer that captures all of the audio data before sending. In general, you get better performance if you stream audio data rather than buffering the data locally. +postContent + :: Text -- ^ 'pcBotName' + -> Text -- ^ 'pcBotAlias' + -> Text -- ^ 'pcUserId' + -> Text -- ^ 'pcContentType' + -> HashedBody -- ^ 'pcInputStream' + -> PostContent +postContent pBotName_ pBotAlias_ pUserId_ pContentType_ pInputStream_ = + PostContent' + { _pcAccept = Nothing + , _pcRequestAttributes = Nothing + , _pcSessionAttributes = Nothing + , _pcBotName = pBotName_ + , _pcBotAlias = pBotAlias_ + , _pcUserId = pUserId_ + , _pcContentType = pContentType_ + , _pcInputStream = pInputStream_ + } + + +-- | You pass this value as the @Accept@ HTTP header. The message Amazon Lex returns in the response can be either text or speech based on the @Accept@ HTTP header value in the request. * If the value is @text/plain; charset=utf-8@ , Amazon Lex returns text in the response. * If the value begins with @audio/@ , Amazon Lex returns speech in the response. Amazon Lex uses Amazon Polly to generate the speech (using the configuration you specified in the @Accept@ header). For example, if you specify @audio/mpeg@ as the value, Amazon Lex returns speech in the MPEG format. The following are the accepted values: * audio/mpeg * audio/ogg * audio/pcm * text/plain; charset=utf-8 * audio/* (defaults to mpeg) +pcAccept :: Lens' PostContent (Maybe Text) +pcAccept = lens _pcAccept (\ s a -> s{_pcAccept = a}); + +-- | You pass this value as the @x-amz-lex-request-attributes@ HTTP header. Request-specific information passed between Amazon Lex and a client application. The value must be a JSON serialized and base64 encoded map with string keys and values. The total size of the @requestAttributes@ and @sessionAttributes@ headers is limited to 12 KB. The namespace @x-amz-lex:@ is reserved for special attributes. Don't create any request attributes with the prefix @x-amz-lex:@ . For more information, see . +pcRequestAttributes :: Lens' PostContent (Maybe Text) +pcRequestAttributes = lens _pcRequestAttributes (\ s a -> s{_pcRequestAttributes = a}) . mapping _Sensitive; + +-- | You pass this value as the @x-amz-lex-session-attributes@ HTTP header. Application-specific information passed between Amazon Lex and a client application. The value must be a JSON serialized and base64 encoded map with string keys and values. The total size of the @sessionAttributes@ and @requestAttributes@ headers is limited to 12 KB. For more information, see . +pcSessionAttributes :: Lens' PostContent (Maybe Text) +pcSessionAttributes = lens _pcSessionAttributes (\ s a -> s{_pcSessionAttributes = a}) . mapping _Sensitive; + +-- | Name of the Amazon Lex bot. +pcBotName :: Lens' PostContent Text +pcBotName = lens _pcBotName (\ s a -> s{_pcBotName = a}); + +-- | Alias of the Amazon Lex bot. +pcBotAlias :: Lens' PostContent Text +pcBotAlias = lens _pcBotAlias (\ s a -> s{_pcBotAlias = a}); + +-- | The ID of the client application user. Amazon Lex uses this to identify a user's conversation with your bot. At runtime, each request must contain the @userID@ field. To decide the user ID to use for your application, consider the following factors. * The @userID@ field must not contain any personally identifiable information of the user, for example, name, personal identification numbers, or other end user personal information. * If you want a user to start a conversation on one device and continue on another device, use a user-specific identifier. * If you want the same user to be able to have two independent conversations on two different devices, choose a device-specific identifier. * A user can't have two independent conversations with two different versions of the same bot. For example, a user can't have a conversation with the PROD and BETA versions of the same bot. If you anticipate that a user will need to have conversation with two different versions, for example, while testing, include the bot alias in the user ID to separate the two conversations. +pcUserId :: Lens' PostContent Text +pcUserId = lens _pcUserId (\ s a -> s{_pcUserId = a}); + +-- | You pass this value as the @Content-Type@ HTTP header. Indicates the audio format or text. The header value must start with one of the following prefixes: * PCM format, audio data must be in little-endian byte order. * audio/l16; rate=16000; channels=1 * audio/x-l16; sample-rate=16000; channel-count=1 * audio/lpcm; sample-rate=8000; sample-size-bits=16; channel-count=1; is-big-endian=false * Opus format * audio/x-cbr-opus-with-preamble; preamble-size=0; bit-rate=256000; frame-size-milliseconds=4 * Text format * text/plain; charset=utf-8 +pcContentType :: Lens' PostContent Text +pcContentType = lens _pcContentType (\ s a -> s{_pcContentType = a}); + +-- | User input in PCM or Opus audio format or text format as described in the @Content-Type@ HTTP header. You can stream audio data to Amazon Lex or you can create a local buffer that captures all of the audio data before sending. In general, you get better performance if you stream audio data rather than buffering the data locally. +pcInputStream :: Lens' PostContent HashedBody +pcInputStream = lens _pcInputStream (\ s a -> s{_pcInputStream = a}); + +instance AWSRequest PostContent where + type Rs PostContent = PostContentResponse + request = postBody lexRuntime + response + = receiveBody + (\ s h x -> + PostContentResponse' <$> + (h .#? "x-amz-lex-slots") <*> + (h .#? "x-amz-lex-intent-name") + <*> (h .#? "x-amz-lex-dialog-state") + <*> (h .#? "x-amz-lex-input-transcript") + <*> (h .#? "x-amz-lex-message") + <*> (h .#? "x-amz-lex-slot-to-elicit") + <*> (h .#? "Content-Type") + <*> (h .#? "x-amz-lex-session-attributes") + <*> (pure (fromEnum s)) + <*> (pure x)) + +instance ToBody PostContent where + toBody = toBody . _pcInputStream + +instance ToHeaders PostContent where + toHeaders PostContent'{..} + = mconcat + ["Accept" =# _pcAccept, + "x-amz-lex-request-attributes" =# + _pcRequestAttributes, + "x-amz-lex-session-attributes" =# + _pcSessionAttributes, + "Content-Type" =# _pcContentType, + "Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)] + +instance ToPath PostContent where + toPath PostContent'{..} + = mconcat + ["/bot/", toBS _pcBotName, "/alias/", + toBS _pcBotAlias, "/user/", toBS _pcUserId, + "/content"] + +instance ToQuery PostContent where + toQuery = const mempty + +-- | /See:/ 'postContentResponse' smart constructor. +data PostContentResponse = PostContentResponse' + { _pcrsSlots :: !(Maybe Text) + , _pcrsIntentName :: !(Maybe Text) + , _pcrsDialogState :: !(Maybe DialogState) + , _pcrsInputTranscript :: !(Maybe Text) + , _pcrsMessage :: !(Maybe (Sensitive Text)) + , _pcrsSlotToElicit :: !(Maybe Text) + , _pcrsContentType :: !(Maybe Text) + , _pcrsSessionAttributes :: !(Maybe Text) + , _pcrsResponseStatus :: !Int + , _pcrsAudioStream :: !RsBody + } deriving (Show, Generic) + + +-- | Creates a value of 'PostContentResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'pcrsSlots' - Map of zero or more intent slots (name/value pairs) Amazon Lex detected from the user input during the conversation. Amazon Lex creates a resolution list containing likely values for a slot. The value that it returns is determined by the @valueSelectionStrategy@ selected when the slot type was created or updated. If @valueSelectionStrategy@ is set to @ORIGINAL_VALUE@ , the value provided by the user is returned, if the user value is similar to the slot values. If @valueSelectionStrategy@ is set to @TOP_RESOLUTION@ Amazon Lex returns the first value in the resolution list or, if there is no resolution list, null. If you don't specify a @valueSelectionStrategy@ , the default is @ORIGINAL_VALUE@ . +-- +-- * 'pcrsIntentName' - Current user intent that Amazon Lex is aware of. +-- +-- * 'pcrsDialogState' - Identifies the current state of the user interaction. Amazon Lex returns one of the following values as @dialogState@ . The client can optionally use this information to customize the user interface. * @ElicitIntent@ - Amazon Lex wants to elicit the user's intent. Consider the following examples: For example, a user might utter an intent ("I want to order a pizza"). If Amazon Lex cannot infer the user intent from this utterance, it will return this dialog state. * @ConfirmIntent@ - Amazon Lex is expecting a "yes" or "no" response. For example, Amazon Lex wants user confirmation before fulfilling an intent. Instead of a simple "yes" or "no" response, a user might respond with additional information. For example, "yes, but make it a thick crust pizza" or "no, I want to order a drink." Amazon Lex can process such additional information (in these examples, update the crust type slot or change the intent from OrderPizza to OrderDrink). * @ElicitSlot@ - Amazon Lex is expecting the value of a slot for the current intent. For example, suppose that in the response Amazon Lex sends this message: "What size pizza would you like?". A user might reply with the slot value (e.g., "medium"). The user might also provide additional information in the response (e.g., "medium thick crust pizza"). Amazon Lex can process such additional information appropriately. * @Fulfilled@ - Conveys that the Lambda function has successfully fulfilled the intent. * @ReadyForFulfillment@ - Conveys that the client has to fulfill the request. * @Failed@ - Conveys that the conversation with the user failed. This can happen for various reasons, including that the user does not provide an appropriate response to prompts from the service (you can configure how many times Amazon Lex can prompt a user for specific information), or if the Lambda function fails to fulfill the intent. +-- +-- * 'pcrsInputTranscript' - The text used to process the request. If the input was an audio stream, the @inputTranscript@ field contains the text extracted from the audio stream. This is the text that is actually processed to recognize intents and slot values. You can use this information to determine if Amazon Lex is correctly processing the audio that you send. +-- +-- * 'pcrsMessage' - Message to convey to the user. It can come from the bot's configuration or a code hook (Lambda function). If the current intent is not configured with a code hook or if the code hook returned @Delegate@ as the @dialogAction.type@ in its response, then Amazon Lex decides the next course of action and selects an appropriate message from the bot configuration based on the current user interaction context. For example, if Amazon Lex is not able to understand the user input, it uses a clarification prompt message (For more information, see the Error Handling section in the Amazon Lex console). Another example: if the intent requires confirmation before fulfillment, then Amazon Lex uses the confirmation prompt message in the intent configuration. If the code hook returns a message, Amazon Lex passes it as-is in its response to the client. +-- +-- * 'pcrsSlotToElicit' - If the @dialogState@ value is @ElicitSlot@ , returns the name of the slot for which Amazon Lex is eliciting a value. +-- +-- * 'pcrsContentType' - Content type as specified in the @Accept@ HTTP header in the request. +-- +-- * 'pcrsSessionAttributes' - Map of key/value pairs representing the session-specific context information. +-- +-- * 'pcrsResponseStatus' - -- | The response status code. +-- +-- * 'pcrsAudioStream' - The prompt (or statement) to convey to the user. This is based on the bot configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the @clarificationPrompt@ configured for the bot. If the intent requires confirmation before taking the fulfillment action, it sends the @confirmationPrompt@ . Another example: Suppose that the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. Then Amazon Lex sends that message in the response. +postContentResponse + :: Int -- ^ 'pcrsResponseStatus' + -> RsBody -- ^ 'pcrsAudioStream' + -> PostContentResponse +postContentResponse pResponseStatus_ pAudioStream_ = + PostContentResponse' + { _pcrsSlots = Nothing + , _pcrsIntentName = Nothing + , _pcrsDialogState = Nothing + , _pcrsInputTranscript = Nothing + , _pcrsMessage = Nothing + , _pcrsSlotToElicit = Nothing + , _pcrsContentType = Nothing + , _pcrsSessionAttributes = Nothing + , _pcrsResponseStatus = pResponseStatus_ + , _pcrsAudioStream = pAudioStream_ + } + + +-- | Map of zero or more intent slots (name/value pairs) Amazon Lex detected from the user input during the conversation. Amazon Lex creates a resolution list containing likely values for a slot. The value that it returns is determined by the @valueSelectionStrategy@ selected when the slot type was created or updated. If @valueSelectionStrategy@ is set to @ORIGINAL_VALUE@ , the value provided by the user is returned, if the user value is similar to the slot values. If @valueSelectionStrategy@ is set to @TOP_RESOLUTION@ Amazon Lex returns the first value in the resolution list or, if there is no resolution list, null. If you don't specify a @valueSelectionStrategy@ , the default is @ORIGINAL_VALUE@ . +pcrsSlots :: Lens' PostContentResponse (Maybe Text) +pcrsSlots = lens _pcrsSlots (\ s a -> s{_pcrsSlots = a}); + +-- | Current user intent that Amazon Lex is aware of. +pcrsIntentName :: Lens' PostContentResponse (Maybe Text) +pcrsIntentName = lens _pcrsIntentName (\ s a -> s{_pcrsIntentName = a}); + +-- | Identifies the current state of the user interaction. Amazon Lex returns one of the following values as @dialogState@ . The client can optionally use this information to customize the user interface. * @ElicitIntent@ - Amazon Lex wants to elicit the user's intent. Consider the following examples: For example, a user might utter an intent ("I want to order a pizza"). If Amazon Lex cannot infer the user intent from this utterance, it will return this dialog state. * @ConfirmIntent@ - Amazon Lex is expecting a "yes" or "no" response. For example, Amazon Lex wants user confirmation before fulfilling an intent. Instead of a simple "yes" or "no" response, a user might respond with additional information. For example, "yes, but make it a thick crust pizza" or "no, I want to order a drink." Amazon Lex can process such additional information (in these examples, update the crust type slot or change the intent from OrderPizza to OrderDrink). * @ElicitSlot@ - Amazon Lex is expecting the value of a slot for the current intent. For example, suppose that in the response Amazon Lex sends this message: "What size pizza would you like?". A user might reply with the slot value (e.g., "medium"). The user might also provide additional information in the response (e.g., "medium thick crust pizza"). Amazon Lex can process such additional information appropriately. * @Fulfilled@ - Conveys that the Lambda function has successfully fulfilled the intent. * @ReadyForFulfillment@ - Conveys that the client has to fulfill the request. * @Failed@ - Conveys that the conversation with the user failed. This can happen for various reasons, including that the user does not provide an appropriate response to prompts from the service (you can configure how many times Amazon Lex can prompt a user for specific information), or if the Lambda function fails to fulfill the intent. +pcrsDialogState :: Lens' PostContentResponse (Maybe DialogState) +pcrsDialogState = lens _pcrsDialogState (\ s a -> s{_pcrsDialogState = a}); + +-- | The text used to process the request. If the input was an audio stream, the @inputTranscript@ field contains the text extracted from the audio stream. This is the text that is actually processed to recognize intents and slot values. You can use this information to determine if Amazon Lex is correctly processing the audio that you send. +pcrsInputTranscript :: Lens' PostContentResponse (Maybe Text) +pcrsInputTranscript = lens _pcrsInputTranscript (\ s a -> s{_pcrsInputTranscript = a}); + +-- | Message to convey to the user. It can come from the bot's configuration or a code hook (Lambda function). If the current intent is not configured with a code hook or if the code hook returned @Delegate@ as the @dialogAction.type@ in its response, then Amazon Lex decides the next course of action and selects an appropriate message from the bot configuration based on the current user interaction context. For example, if Amazon Lex is not able to understand the user input, it uses a clarification prompt message (For more information, see the Error Handling section in the Amazon Lex console). Another example: if the intent requires confirmation before fulfillment, then Amazon Lex uses the confirmation prompt message in the intent configuration. If the code hook returns a message, Amazon Lex passes it as-is in its response to the client. +pcrsMessage :: Lens' PostContentResponse (Maybe Text) +pcrsMessage = lens _pcrsMessage (\ s a -> s{_pcrsMessage = a}) . mapping _Sensitive; + +-- | If the @dialogState@ value is @ElicitSlot@ , returns the name of the slot for which Amazon Lex is eliciting a value. +pcrsSlotToElicit :: Lens' PostContentResponse (Maybe Text) +pcrsSlotToElicit = lens _pcrsSlotToElicit (\ s a -> s{_pcrsSlotToElicit = a}); + +-- | Content type as specified in the @Accept@ HTTP header in the request. +pcrsContentType :: Lens' PostContentResponse (Maybe Text) +pcrsContentType = lens _pcrsContentType (\ s a -> s{_pcrsContentType = a}); + +-- | Map of key/value pairs representing the session-specific context information. +pcrsSessionAttributes :: Lens' PostContentResponse (Maybe Text) +pcrsSessionAttributes = lens _pcrsSessionAttributes (\ s a -> s{_pcrsSessionAttributes = a}); + +-- | -- | The response status code. +pcrsResponseStatus :: Lens' PostContentResponse Int +pcrsResponseStatus = lens _pcrsResponseStatus (\ s a -> s{_pcrsResponseStatus = a}); + +-- | The prompt (or statement) to convey to the user. This is based on the bot configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the @clarificationPrompt@ configured for the bot. If the intent requires confirmation before taking the fulfillment action, it sends the @confirmationPrompt@ . Another example: Suppose that the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. Then Amazon Lex sends that message in the response. +pcrsAudioStream :: Lens' PostContentResponse RsBody +pcrsAudioStream = lens _pcrsAudioStream (\ s a -> s{_pcrsAudioStream = a}); diff --git a/gen/Network/AWS/LexRuntime/PostText.hs b/gen/Network/AWS/LexRuntime/PostText.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/LexRuntime/PostText.hs @@ -0,0 +1,280 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-matches #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.LexRuntime.PostText +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Sends user input (text-only) to Amazon Lex. Client applications can use this API to send requests to Amazon Lex at runtime. Amazon Lex then interprets the user input using the machine learning model it built for the bot. +-- +-- +-- In response, Amazon Lex returns the next @message@ to convey to the user an optional @responseCard@ to display. Consider the following example messages: +-- +-- * For a user input "I would like a pizza", Amazon Lex might return a response with a message eliciting slot data (for example, PizzaSize): "What size pizza would you like?" +-- +-- * After the user provides all of the pizza order information, Amazon Lex might return a response with a message to obtain user confirmation "Proceed with the pizza order?". +-- +-- * After the user replies to a confirmation prompt with a "yes", Amazon Lex might return a conclusion statement: "Thank you, your cheese pizza has been ordered.". +-- +-- +-- +-- Not all Amazon Lex messages require a user response. For example, a conclusion statement does not require a response. Some messages require only a "yes" or "no" user response. In addition to the @message@ , Amazon Lex provides additional context about the message in the response that you might use to enhance client behavior, for example, to display the appropriate client user interface. These are the @slotToElicit@ , @dialogState@ , @intentName@ , and @slots@ fields in the response. Consider the following examples: +-- +-- * If the message is to elicit slot data, Amazon Lex returns the following context information: +-- +-- * @dialogState@ set to ElicitSlot +-- +-- * @intentName@ set to the intent name in the current context +-- +-- * @slotToElicit@ set to the slot name for which the @message@ is eliciting information +-- +-- * @slots@ set to a map of slots, configured for the intent, with currently known values +-- +-- +-- +-- * If the message is a confirmation prompt, the @dialogState@ is set to ConfirmIntent and @SlotToElicit@ is set to null. +-- +-- * If the message is a clarification prompt (configured for the intent) that indicates that user intent is not understood, the @dialogState@ is set to ElicitIntent and @slotToElicit@ is set to null. +-- +-- +-- +-- In addition, Amazon Lex also returns your application-specific @sessionAttributes@ . For more information, see . +-- +module Network.AWS.LexRuntime.PostText + ( + -- * Creating a Request + postText + , PostText + -- * Request Lenses + , ptRequestAttributes + , ptSessionAttributes + , ptBotName + , ptBotAlias + , ptUserId + , ptInputText + + -- * Destructuring the Response + , postTextResponse + , PostTextResponse + -- * Response Lenses + , ptrsSlots + , ptrsResponseCard + , ptrsIntentName + , ptrsDialogState + , ptrsMessage + , ptrsSlotToElicit + , ptrsSessionAttributes + , ptrsResponseStatus + ) where + +import Network.AWS.Lens +import Network.AWS.LexRuntime.Types +import Network.AWS.LexRuntime.Types.Product +import Network.AWS.Prelude +import Network.AWS.Request +import Network.AWS.Response + +-- | /See:/ 'postText' smart constructor. +data PostText = PostText' + { _ptRequestAttributes :: !(Maybe (Sensitive (Map Text Text))) + , _ptSessionAttributes :: !(Maybe (Sensitive (Map Text Text))) + , _ptBotName :: !Text + , _ptBotAlias :: !Text + , _ptUserId :: !Text + , _ptInputText :: !(Sensitive Text) + } deriving (Eq, Show, Data, Typeable, Generic) + + +-- | Creates a value of 'PostText' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ptRequestAttributes' - Request-specific information passed between Amazon Lex and a client application. The namespace @x-amz-lex:@ is reserved for special attributes. Don't create any request attributes with the prefix @x-amz-lex:@ . For more information, see . +-- +-- * 'ptSessionAttributes' - Application-specific information passed between Amazon Lex and a client application. For more information, see . +-- +-- * 'ptBotName' - The name of the Amazon Lex bot. +-- +-- * 'ptBotAlias' - The alias of the Amazon Lex bot. +-- +-- * 'ptUserId' - The ID of the client application user. Amazon Lex uses this to identify a user's conversation with your bot. At runtime, each request must contain the @userID@ field. To decide the user ID to use for your application, consider the following factors. * The @userID@ field must not contain any personally identifiable information of the user, for example, name, personal identification numbers, or other end user personal information. * If you want a user to start a conversation on one device and continue on another device, use a user-specific identifier. * If you want the same user to be able to have two independent conversations on two different devices, choose a device-specific identifier. * A user can't have two independent conversations with two different versions of the same bot. For example, a user can't have a conversation with the PROD and BETA versions of the same bot. If you anticipate that a user will need to have conversation with two different versions, for example, while testing, include the bot alias in the user ID to separate the two conversations. +-- +-- * 'ptInputText' - The text that the user entered (Amazon Lex interprets this text). +postText + :: Text -- ^ 'ptBotName' + -> Text -- ^ 'ptBotAlias' + -> Text -- ^ 'ptUserId' + -> Text -- ^ 'ptInputText' + -> PostText +postText pBotName_ pBotAlias_ pUserId_ pInputText_ = + PostText' + { _ptRequestAttributes = Nothing + , _ptSessionAttributes = Nothing + , _ptBotName = pBotName_ + , _ptBotAlias = pBotAlias_ + , _ptUserId = pUserId_ + , _ptInputText = _Sensitive # pInputText_ + } + + +-- | Request-specific information passed between Amazon Lex and a client application. The namespace @x-amz-lex:@ is reserved for special attributes. Don't create any request attributes with the prefix @x-amz-lex:@ . For more information, see . +ptRequestAttributes :: Lens' PostText (Maybe (HashMap Text Text)) +ptRequestAttributes = lens _ptRequestAttributes (\ s a -> s{_ptRequestAttributes = a}) . mapping (_Sensitive . _Map); + +-- | Application-specific information passed between Amazon Lex and a client application. For more information, see . +ptSessionAttributes :: Lens' PostText (Maybe (HashMap Text Text)) +ptSessionAttributes = lens _ptSessionAttributes (\ s a -> s{_ptSessionAttributes = a}) . mapping (_Sensitive . _Map); + +-- | The name of the Amazon Lex bot. +ptBotName :: Lens' PostText Text +ptBotName = lens _ptBotName (\ s a -> s{_ptBotName = a}); + +-- | The alias of the Amazon Lex bot. +ptBotAlias :: Lens' PostText Text +ptBotAlias = lens _ptBotAlias (\ s a -> s{_ptBotAlias = a}); + +-- | The ID of the client application user. Amazon Lex uses this to identify a user's conversation with your bot. At runtime, each request must contain the @userID@ field. To decide the user ID to use for your application, consider the following factors. * The @userID@ field must not contain any personally identifiable information of the user, for example, name, personal identification numbers, or other end user personal information. * If you want a user to start a conversation on one device and continue on another device, use a user-specific identifier. * If you want the same user to be able to have two independent conversations on two different devices, choose a device-specific identifier. * A user can't have two independent conversations with two different versions of the same bot. For example, a user can't have a conversation with the PROD and BETA versions of the same bot. If you anticipate that a user will need to have conversation with two different versions, for example, while testing, include the bot alias in the user ID to separate the two conversations. +ptUserId :: Lens' PostText Text +ptUserId = lens _ptUserId (\ s a -> s{_ptUserId = a}); + +-- | The text that the user entered (Amazon Lex interprets this text). +ptInputText :: Lens' PostText Text +ptInputText = lens _ptInputText (\ s a -> s{_ptInputText = a}) . _Sensitive; + +instance AWSRequest PostText where + type Rs PostText = PostTextResponse + request = postJSON lexRuntime + response + = receiveJSON + (\ s h x -> + PostTextResponse' <$> + (x .?> "slots" .!@ mempty) <*> (x .?> "responseCard") + <*> (x .?> "intentName") + <*> (x .?> "dialogState") + <*> (x .?> "message") + <*> (x .?> "slotToElicit") + <*> (x .?> "sessionAttributes" .!@ mempty) + <*> (pure (fromEnum s))) + +instance Hashable PostText where + +instance NFData PostText where + +instance ToHeaders PostText where + toHeaders + = const + (mconcat + ["Content-Type" =# + ("application/x-amz-json-1.1" :: ByteString)]) + +instance ToJSON PostText where + toJSON PostText'{..} + = object + (catMaybes + [("requestAttributes" .=) <$> _ptRequestAttributes, + ("sessionAttributes" .=) <$> _ptSessionAttributes, + Just ("inputText" .= _ptInputText)]) + +instance ToPath PostText where + toPath PostText'{..} + = mconcat + ["/bot/", toBS _ptBotName, "/alias/", + toBS _ptBotAlias, "/user/", toBS _ptUserId, "/text"] + +instance ToQuery PostText where + toQuery = const mempty + +-- | /See:/ 'postTextResponse' smart constructor. +data PostTextResponse = PostTextResponse' + { _ptrsSlots :: !(Maybe (Sensitive (Map Text Text))) + , _ptrsResponseCard :: !(Maybe ResponseCard) + , _ptrsIntentName :: !(Maybe Text) + , _ptrsDialogState :: !(Maybe DialogState) + , _ptrsMessage :: !(Maybe (Sensitive Text)) + , _ptrsSlotToElicit :: !(Maybe Text) + , _ptrsSessionAttributes :: !(Maybe (Sensitive (Map Text Text))) + , _ptrsResponseStatus :: !Int + } deriving (Eq, Show, Data, Typeable, Generic) + + +-- | Creates a value of 'PostTextResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ptrsSlots' - The intent slots that Amazon Lex detected from the user input in the conversation. Amazon Lex creates a resolution list containing likely values for a slot. The value that it returns is determined by the @valueSelectionStrategy@ selected when the slot type was created or updated. If @valueSelectionStrategy@ is set to @ORIGINAL_VALUE@ , the value provided by the user is returned, if the user value is similar to the slot values. If @valueSelectionStrategy@ is set to @TOP_RESOLUTION@ Amazon Lex returns the first value in the resolution list or, if there is no resolution list, null. If you don't specify a @valueSelectionStrategy@ , the default is @ORIGINAL_VALUE@ . +-- +-- * 'ptrsResponseCard' - Represents the options that the user has to respond to the current prompt. Response Card can come from the bot configuration (in the Amazon Lex console, choose the settings button next to a slot) or from a code hook (Lambda function). +-- +-- * 'ptrsIntentName' - The current user intent that Amazon Lex is aware of. +-- +-- * 'ptrsDialogState' - Identifies the current state of the user interaction. Amazon Lex returns one of the following values as @dialogState@ . The client can optionally use this information to customize the user interface. * @ElicitIntent@ - Amazon Lex wants to elicit user intent. For example, a user might utter an intent ("I want to order a pizza"). If Amazon Lex cannot infer the user intent from this utterance, it will return this dialogState. * @ConfirmIntent@ - Amazon Lex is expecting a "yes" or "no" response. For example, Amazon Lex wants user confirmation before fulfilling an intent. Instead of a simple "yes" or "no," a user might respond with additional information. For example, "yes, but make it thick crust pizza" or "no, I want to order a drink". Amazon Lex can process such additional information (in these examples, update the crust type slot value, or change intent from OrderPizza to OrderDrink). * @ElicitSlot@ - Amazon Lex is expecting a slot value for the current intent. For example, suppose that in the response Amazon Lex sends this message: "What size pizza would you like?". A user might reply with the slot value (e.g., "medium"). The user might also provide additional information in the response (e.g., "medium thick crust pizza"). Amazon Lex can process such additional information appropriately. * @Fulfilled@ - Conveys that the Lambda function configured for the intent has successfully fulfilled the intent. * @ReadyForFulfillment@ - Conveys that the client has to fulfill the intent. * @Failed@ - Conveys that the conversation with the user failed. This can happen for various reasons including that the user did not provide an appropriate response to prompts from the service (you can configure how many times Amazon Lex can prompt a user for specific information), or the Lambda function failed to fulfill the intent. +-- +-- * 'ptrsMessage' - A message to convey to the user. It can come from the bot's configuration or a code hook (Lambda function). If the current intent is not configured with a code hook or the code hook returned @Delegate@ as the @dialogAction.type@ in its response, then Amazon Lex decides the next course of action and selects an appropriate message from the bot configuration based on the current user interaction context. For example, if Amazon Lex is not able to understand the user input, it uses a clarification prompt message (for more information, see the Error Handling section in the Amazon Lex console). Another example: if the intent requires confirmation before fulfillment, then Amazon Lex uses the confirmation prompt message in the intent configuration. If the code hook returns a message, Amazon Lex passes it as-is in its response to the client. +-- +-- * 'ptrsSlotToElicit' - If the @dialogState@ value is @ElicitSlot@ , returns the name of the slot for which Amazon Lex is eliciting a value. +-- +-- * 'ptrsSessionAttributes' - A map of key-value pairs representing the session-specific context information. +-- +-- * 'ptrsResponseStatus' - -- | The response status code. +postTextResponse + :: Int -- ^ 'ptrsResponseStatus' + -> PostTextResponse +postTextResponse pResponseStatus_ = + PostTextResponse' + { _ptrsSlots = Nothing + , _ptrsResponseCard = Nothing + , _ptrsIntentName = Nothing + , _ptrsDialogState = Nothing + , _ptrsMessage = Nothing + , _ptrsSlotToElicit = Nothing + , _ptrsSessionAttributes = Nothing + , _ptrsResponseStatus = pResponseStatus_ + } + + +-- | The intent slots that Amazon Lex detected from the user input in the conversation. Amazon Lex creates a resolution list containing likely values for a slot. The value that it returns is determined by the @valueSelectionStrategy@ selected when the slot type was created or updated. If @valueSelectionStrategy@ is set to @ORIGINAL_VALUE@ , the value provided by the user is returned, if the user value is similar to the slot values. If @valueSelectionStrategy@ is set to @TOP_RESOLUTION@ Amazon Lex returns the first value in the resolution list or, if there is no resolution list, null. If you don't specify a @valueSelectionStrategy@ , the default is @ORIGINAL_VALUE@ . +ptrsSlots :: Lens' PostTextResponse (Maybe (HashMap Text Text)) +ptrsSlots = lens _ptrsSlots (\ s a -> s{_ptrsSlots = a}) . mapping (_Sensitive . _Map); + +-- | Represents the options that the user has to respond to the current prompt. Response Card can come from the bot configuration (in the Amazon Lex console, choose the settings button next to a slot) or from a code hook (Lambda function). +ptrsResponseCard :: Lens' PostTextResponse (Maybe ResponseCard) +ptrsResponseCard = lens _ptrsResponseCard (\ s a -> s{_ptrsResponseCard = a}); + +-- | The current user intent that Amazon Lex is aware of. +ptrsIntentName :: Lens' PostTextResponse (Maybe Text) +ptrsIntentName = lens _ptrsIntentName (\ s a -> s{_ptrsIntentName = a}); + +-- | Identifies the current state of the user interaction. Amazon Lex returns one of the following values as @dialogState@ . The client can optionally use this information to customize the user interface. * @ElicitIntent@ - Amazon Lex wants to elicit user intent. For example, a user might utter an intent ("I want to order a pizza"). If Amazon Lex cannot infer the user intent from this utterance, it will return this dialogState. * @ConfirmIntent@ - Amazon Lex is expecting a "yes" or "no" response. For example, Amazon Lex wants user confirmation before fulfilling an intent. Instead of a simple "yes" or "no," a user might respond with additional information. For example, "yes, but make it thick crust pizza" or "no, I want to order a drink". Amazon Lex can process such additional information (in these examples, update the crust type slot value, or change intent from OrderPizza to OrderDrink). * @ElicitSlot@ - Amazon Lex is expecting a slot value for the current intent. For example, suppose that in the response Amazon Lex sends this message: "What size pizza would you like?". A user might reply with the slot value (e.g., "medium"). The user might also provide additional information in the response (e.g., "medium thick crust pizza"). Amazon Lex can process such additional information appropriately. * @Fulfilled@ - Conveys that the Lambda function configured for the intent has successfully fulfilled the intent. * @ReadyForFulfillment@ - Conveys that the client has to fulfill the intent. * @Failed@ - Conveys that the conversation with the user failed. This can happen for various reasons including that the user did not provide an appropriate response to prompts from the service (you can configure how many times Amazon Lex can prompt a user for specific information), or the Lambda function failed to fulfill the intent. +ptrsDialogState :: Lens' PostTextResponse (Maybe DialogState) +ptrsDialogState = lens _ptrsDialogState (\ s a -> s{_ptrsDialogState = a}); + +-- | A message to convey to the user. It can come from the bot's configuration or a code hook (Lambda function). If the current intent is not configured with a code hook or the code hook returned @Delegate@ as the @dialogAction.type@ in its response, then Amazon Lex decides the next course of action and selects an appropriate message from the bot configuration based on the current user interaction context. For example, if Amazon Lex is not able to understand the user input, it uses a clarification prompt message (for more information, see the Error Handling section in the Amazon Lex console). Another example: if the intent requires confirmation before fulfillment, then Amazon Lex uses the confirmation prompt message in the intent configuration. If the code hook returns a message, Amazon Lex passes it as-is in its response to the client. +ptrsMessage :: Lens' PostTextResponse (Maybe Text) +ptrsMessage = lens _ptrsMessage (\ s a -> s{_ptrsMessage = a}) . mapping _Sensitive; + +-- | If the @dialogState@ value is @ElicitSlot@ , returns the name of the slot for which Amazon Lex is eliciting a value. +ptrsSlotToElicit :: Lens' PostTextResponse (Maybe Text) +ptrsSlotToElicit = lens _ptrsSlotToElicit (\ s a -> s{_ptrsSlotToElicit = a}); + +-- | A map of key-value pairs representing the session-specific context information. +ptrsSessionAttributes :: Lens' PostTextResponse (Maybe (HashMap Text Text)) +ptrsSessionAttributes = lens _ptrsSessionAttributes (\ s a -> s{_ptrsSessionAttributes = a}) . mapping (_Sensitive . _Map); + +-- | -- | The response status code. +ptrsResponseStatus :: Lens' PostTextResponse Int +ptrsResponseStatus = lens _ptrsResponseStatus (\ s a -> s{_ptrsResponseStatus = a}); + +instance NFData PostTextResponse where diff --git a/gen/Network/AWS/LexRuntime/Types.hs b/gen/Network/AWS/LexRuntime/Types.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/LexRuntime/Types.hs @@ -0,0 +1,197 @@ +{-# LANGUAGE OverloadedStrings #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.LexRuntime.Types +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.LexRuntime.Types + ( + -- * Service Configuration + lexRuntime + + -- * Errors + , _NotAcceptableException + , _DependencyFailedException + , _UnsupportedMediaTypeException + , _ConflictException + , _NotFoundException + , _RequestTimeoutException + , _LoopDetectedException + , _InternalFailureException + , _BadGatewayException + , _BadRequestException + , _LimitExceededException + + -- * ContentType + , ContentType (..) + + -- * DialogState + , DialogState (..) + + -- * Button + , Button + , button + , bText + , bValue + + -- * GenericAttachment + , GenericAttachment + , genericAttachment + , gaButtons + , gaSubTitle + , gaImageURL + , gaAttachmentLinkURL + , gaTitle + + -- * ResponseCard + , ResponseCard + , responseCard + , rcGenericAttachments + , rcVersion + , rcContentType + ) where + +import Network.AWS.Lens +import Network.AWS.LexRuntime.Types.Product +import Network.AWS.LexRuntime.Types.Sum +import Network.AWS.Prelude +import Network.AWS.Sign.V4 + +-- | API version @2016-11-28@ of the Amazon Lex Runtime Service SDK configuration. +lexRuntime :: Service +lexRuntime = + Service + { _svcAbbrev = "LexRuntime" + , _svcSigner = v4 + , _svcPrefix = "runtime.lex" + , _svcVersion = "2016-11-28" + , _svcEndpoint = defaultEndpoint lexRuntime + , _svcTimeout = Just 70 + , _svcCheck = statusSuccess + , _svcError = parseJSONError "LexRuntime" + , _svcRetry = retry + } + where + retry = + Exponential + { _retryBase = 5.0e-2 + , _retryGrowth = 2 + , _retryAttempts = 5 + , _retryCheck = check + } + check e + | has (hasCode "ThrottledException" . hasStatus 400) e = + Just "throttled_exception" + | has (hasStatus 429) e = Just "too_many_requests" + | has (hasCode "ThrottlingException" . hasStatus 400) e = + Just "throttling_exception" + | has (hasCode "Throttling" . hasStatus 400) e = Just "throttling" + | has (hasStatus 504) e = Just "gateway_timeout" + | has (hasStatus 502) e = Just "bad_gateway" + | has (hasStatus 503) e = Just "service_unavailable" + | has (hasStatus 500) e = Just "general_server_error" + | has (hasStatus 509) e = Just "limit_exceeded" + | otherwise = Nothing + + +-- | The accept header in the request does not have a valid value. +-- +-- +_NotAcceptableException :: AsError a => Getting (First ServiceError) a ServiceError +_NotAcceptableException = + _MatchServiceError lexRuntime "NotAcceptableException" . hasStatus 406 + + +-- | One of the dependencies, such as AWS Lambda or Amazon Polly, threw an exception. For example, +-- +-- +-- * If Amazon Lex does not have sufficient permissions to call a Lambda function. +-- +-- * If a Lambda function takes longer than 30 seconds to execute. +-- +-- * If a fulfillment Lambda function returns a @Delegate@ dialog action without removing any slot values. +-- +-- +-- +_DependencyFailedException :: AsError a => Getting (First ServiceError) a ServiceError +_DependencyFailedException = + _MatchServiceError lexRuntime "DependencyFailedException" . hasStatus 424 + + +-- | The Content-Type header (@PostContent@ API) has an invalid value. +-- +-- +_UnsupportedMediaTypeException :: AsError a => Getting (First ServiceError) a ServiceError +_UnsupportedMediaTypeException = + _MatchServiceError lexRuntime "UnsupportedMediaTypeException" . hasStatus 415 + + +-- | Two clients are using the same AWS account, Amazon Lex bot, and user ID. +-- +-- +_ConflictException :: AsError a => Getting (First ServiceError) a ServiceError +_ConflictException = + _MatchServiceError lexRuntime "ConflictException" . hasStatus 409 + + +-- | The resource (such as the Amazon Lex bot or an alias) that is referred to is not found. +-- +-- +_NotFoundException :: AsError a => Getting (First ServiceError) a ServiceError +_NotFoundException = + _MatchServiceError lexRuntime "NotFoundException" . hasStatus 404 + + +-- | The input speech is too long. +-- +-- +_RequestTimeoutException :: AsError a => Getting (First ServiceError) a ServiceError +_RequestTimeoutException = + _MatchServiceError lexRuntime "RequestTimeoutException" . hasStatus 408 + + +-- | This exception is not used. +-- +-- +_LoopDetectedException :: AsError a => Getting (First ServiceError) a ServiceError +_LoopDetectedException = + _MatchServiceError lexRuntime "LoopDetectedException" . hasStatus 508 + + +-- | Internal service error. Retry the call. +-- +-- +_InternalFailureException :: AsError a => Getting (First ServiceError) a ServiceError +_InternalFailureException = + _MatchServiceError lexRuntime "InternalFailureException" . hasStatus 500 + + +-- | Either the Amazon Lex bot is still building, or one of the dependent services (Amazon Polly, AWS Lambda) failed with an internal service error. +-- +-- +_BadGatewayException :: AsError a => Getting (First ServiceError) a ServiceError +_BadGatewayException = + _MatchServiceError lexRuntime "BadGatewayException" . hasStatus 502 + + +-- | Request validation failed, there is no usable message in the context, or the bot build failed, is still in progress, or contains unbuilt changes. +-- +-- +_BadRequestException :: AsError a => Getting (First ServiceError) a ServiceError +_BadRequestException = + _MatchServiceError lexRuntime "BadRequestException" . hasStatus 400 + + +-- | Exceeded a limit. +-- +-- +_LimitExceededException :: AsError a => Getting (First ServiceError) a ServiceError +_LimitExceededException = + _MatchServiceError lexRuntime "LimitExceededException" . hasStatus 429 + diff --git a/gen/Network/AWS/LexRuntime/Types/Product.hs b/gen/Network/AWS/LexRuntime/Types/Product.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/LexRuntime/Types/Product.hs @@ -0,0 +1,193 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.LexRuntime.Types.Product +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.LexRuntime.Types.Product where + +import Network.AWS.Lens +import Network.AWS.LexRuntime.Types.Sum +import Network.AWS.Prelude + +-- | Represents an option to be shown on the client platform (Facebook, Slack, etc.) +-- +-- +-- +-- /See:/ 'button' smart constructor. +data Button = Button' + { _bText :: !Text + , _bValue :: !Text + } deriving (Eq, Read, Show, Data, Typeable, Generic) + + +-- | Creates a value of 'Button' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'bText' - Text that is visible to the user on the button. +-- +-- * 'bValue' - The value sent to Amazon Lex when a user chooses the button. For example, consider button text "NYC." When the user chooses the button, the value sent can be "New York City." +button + :: Text -- ^ 'bText' + -> Text -- ^ 'bValue' + -> Button +button pText_ pValue_ = Button' {_bText = pText_, _bValue = pValue_} + + +-- | Text that is visible to the user on the button. +bText :: Lens' Button Text +bText = lens _bText (\ s a -> s{_bText = a}); + +-- | The value sent to Amazon Lex when a user chooses the button. For example, consider button text "NYC." When the user chooses the button, the value sent can be "New York City." +bValue :: Lens' Button Text +bValue = lens _bValue (\ s a -> s{_bValue = a}); + +instance FromJSON Button where + parseJSON + = withObject "Button" + (\ x -> Button' <$> (x .: "text") <*> (x .: "value")) + +instance Hashable Button where + +instance NFData Button where + +-- | Represents an option rendered to the user when a prompt is shown. It could be an image, a button, a link, or text. +-- +-- +-- +-- /See:/ 'genericAttachment' smart constructor. +data GenericAttachment = GenericAttachment' + { _gaButtons :: !(Maybe [Button]) + , _gaSubTitle :: !(Maybe Text) + , _gaImageURL :: !(Maybe Text) + , _gaAttachmentLinkURL :: !(Maybe Text) + , _gaTitle :: !(Maybe Text) + } deriving (Eq, Read, Show, Data, Typeable, Generic) + + +-- | Creates a value of 'GenericAttachment' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'gaButtons' - The list of options to show to the user. +-- +-- * 'gaSubTitle' - The subtitle shown below the title. +-- +-- * 'gaImageURL' - The URL of an image that is displayed to the user. +-- +-- * 'gaAttachmentLinkURL' - The URL of an attachment to the response card. +-- +-- * 'gaTitle' - The title of the option. +genericAttachment + :: GenericAttachment +genericAttachment = + GenericAttachment' + { _gaButtons = Nothing + , _gaSubTitle = Nothing + , _gaImageURL = Nothing + , _gaAttachmentLinkURL = Nothing + , _gaTitle = Nothing + } + + +-- | The list of options to show to the user. +gaButtons :: Lens' GenericAttachment [Button] +gaButtons = lens _gaButtons (\ s a -> s{_gaButtons = a}) . _Default . _Coerce; + +-- | The subtitle shown below the title. +gaSubTitle :: Lens' GenericAttachment (Maybe Text) +gaSubTitle = lens _gaSubTitle (\ s a -> s{_gaSubTitle = a}); + +-- | The URL of an image that is displayed to the user. +gaImageURL :: Lens' GenericAttachment (Maybe Text) +gaImageURL = lens _gaImageURL (\ s a -> s{_gaImageURL = a}); + +-- | The URL of an attachment to the response card. +gaAttachmentLinkURL :: Lens' GenericAttachment (Maybe Text) +gaAttachmentLinkURL = lens _gaAttachmentLinkURL (\ s a -> s{_gaAttachmentLinkURL = a}); + +-- | The title of the option. +gaTitle :: Lens' GenericAttachment (Maybe Text) +gaTitle = lens _gaTitle (\ s a -> s{_gaTitle = a}); + +instance FromJSON GenericAttachment where + parseJSON + = withObject "GenericAttachment" + (\ x -> + GenericAttachment' <$> + (x .:? "buttons" .!= mempty) <*> (x .:? "subTitle") + <*> (x .:? "imageUrl") + <*> (x .:? "attachmentLinkUrl") + <*> (x .:? "title")) + +instance Hashable GenericAttachment where + +instance NFData GenericAttachment where + +-- | If you configure a response card when creating your bots, Amazon Lex substitutes the session attributes and slot values that are available, and then returns it. The response card can also come from a Lambda function ( @dialogCodeHook@ and @fulfillmentActivity@ on an intent). +-- +-- +-- +-- /See:/ 'responseCard' smart constructor. +data ResponseCard = ResponseCard' + { _rcGenericAttachments :: !(Maybe [GenericAttachment]) + , _rcVersion :: !(Maybe Text) + , _rcContentType :: !(Maybe ContentType) + } deriving (Eq, Read, Show, Data, Typeable, Generic) + + +-- | Creates a value of 'ResponseCard' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'rcGenericAttachments' - An array of attachment objects representing options. +-- +-- * 'rcVersion' - The version of the response card format. +-- +-- * 'rcContentType' - The content type of the response. +responseCard + :: ResponseCard +responseCard = + ResponseCard' + { _rcGenericAttachments = Nothing + , _rcVersion = Nothing + , _rcContentType = Nothing + } + + +-- | An array of attachment objects representing options. +rcGenericAttachments :: Lens' ResponseCard [GenericAttachment] +rcGenericAttachments = lens _rcGenericAttachments (\ s a -> s{_rcGenericAttachments = a}) . _Default . _Coerce; + +-- | The version of the response card format. +rcVersion :: Lens' ResponseCard (Maybe Text) +rcVersion = lens _rcVersion (\ s a -> s{_rcVersion = a}); + +-- | The content type of the response. +rcContentType :: Lens' ResponseCard (Maybe ContentType) +rcContentType = lens _rcContentType (\ s a -> s{_rcContentType = a}); + +instance FromJSON ResponseCard where + parseJSON + = withObject "ResponseCard" + (\ x -> + ResponseCard' <$> + (x .:? "genericAttachments" .!= mempty) <*> + (x .:? "version") + <*> (x .:? "contentType")) + +instance Hashable ResponseCard where + +instance NFData ResponseCard where diff --git a/gen/Network/AWS/LexRuntime/Types/Sum.hs b/gen/Network/AWS/LexRuntime/Types/Sum.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/LexRuntime/Types/Sum.hs @@ -0,0 +1,83 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.LexRuntime.Types.Sum +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.LexRuntime.Types.Sum where + +import Network.AWS.Prelude + +data ContentType = + ApplicationVnd_Amazonaws_Card_Generic + deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic) + + +instance FromText ContentType where + parser = takeLowerText >>= \case + "application/vnd.amazonaws.card.generic" -> pure ApplicationVnd_Amazonaws_Card_Generic + e -> fromTextError $ "Failure parsing ContentType from value: '" <> e + <> "'. Accepted values: application/vnd.amazonaws.card.generic" + +instance ToText ContentType where + toText = \case + ApplicationVnd_Amazonaws_Card_Generic -> "application/vnd.amazonaws.card.generic" + +instance Hashable ContentType +instance NFData ContentType +instance ToByteString ContentType +instance ToQuery ContentType +instance ToHeader ContentType + +instance FromJSON ContentType where + parseJSON = parseJSONText "ContentType" + +data DialogState + = ConfirmIntent + | ElicitIntent + | ElicitSlot + | Failed + | Fulfilled + | ReadyForFulfillment + deriving (Eq, Ord, Read, Show, Enum, Bounded, Data, Typeable, Generic) + + +instance FromText DialogState where + parser = takeLowerText >>= \case + "confirmintent" -> pure ConfirmIntent + "elicitintent" -> pure ElicitIntent + "elicitslot" -> pure ElicitSlot + "failed" -> pure Failed + "fulfilled" -> pure Fulfilled + "readyforfulfillment" -> pure ReadyForFulfillment + e -> fromTextError $ "Failure parsing DialogState from value: '" <> e + <> "'. Accepted values: confirmintent, elicitintent, elicitslot, failed, fulfilled, readyforfulfillment" + +instance ToText DialogState where + toText = \case + ConfirmIntent -> "ConfirmIntent" + ElicitIntent -> "ElicitIntent" + ElicitSlot -> "ElicitSlot" + Failed -> "Failed" + Fulfilled -> "Fulfilled" + ReadyForFulfillment -> "ReadyForFulfillment" + +instance Hashable DialogState +instance NFData DialogState +instance ToByteString DialogState +instance ToQuery DialogState +instance ToHeader DialogState + +instance FromJSON DialogState where + parseJSON = parseJSONText "DialogState" diff --git a/gen/Network/AWS/LexRuntime/Waiters.hs b/gen/Network/AWS/LexRuntime/Waiters.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/LexRuntime/Waiters.hs @@ -0,0 +1,21 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Network.AWS.LexRuntime.Waiters +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.AWS.LexRuntime.Waiters where + +import Network.AWS.Lens +import Network.AWS.LexRuntime.Types +import Network.AWS.Prelude +import Network.AWS.Waiter diff --git a/src/.gitkeep b/src/.gitkeep new file mode 100644 --- /dev/null +++ b/src/.gitkeep diff --git a/test/Main.hs b/test/Main.hs new file mode 100644 --- /dev/null +++ b/test/Main.hs @@ -0,0 +1,21 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Main +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Main (main) where + +import Test.Tasty +import Test.AWS.LexRuntime +import Test.AWS.LexRuntime.Internal + +main :: IO () +main = defaultMain $ testGroup "LexRuntime" + [ testGroup "tests" tests + , testGroup "fixtures" fixtures + ] diff --git a/test/Test/AWS/Gen/LexRuntime.hs b/test/Test/AWS/Gen/LexRuntime.hs new file mode 100644 --- /dev/null +++ b/test/Test/AWS/Gen/LexRuntime.hs @@ -0,0 +1,63 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} + +-- Derived from AWS service descriptions, licensed under Apache 2.0. + +-- | +-- Module : Test.AWS.Gen.LexRuntime +-- Copyright : (c) 2013-2017 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Test.AWS.Gen.LexRuntime where + +import Data.Proxy +import Network.AWS.LexRuntime +import Test.AWS.Fixture +import Test.AWS.LexRuntime.Internal +import Test.AWS.Prelude +import Test.Tasty + +-- Auto-generated: the actual test selection needs to be manually placed into +-- the top-level so that real test data can be incrementally added. +-- +-- This commented snippet is what the entire set should look like: + +-- fixtures :: TestTree +-- fixtures = +-- [ testGroup "request" +-- [ requestPostText $ +-- postText +-- +-- , requestPostContent $ +-- postContent +-- +-- ] + +-- , testGroup "response" +-- [ responsePostText $ +-- postTextResponse +-- +-- , responsePostContent $ +-- postContentResponse +-- +-- ] +-- ] + +-- Requests + +requestPostText :: PostText -> TestTree +requestPostText = req + "PostText" + "fixture/PostText.yaml" + +-- Responses + +responsePostText :: PostTextResponse -> TestTree +responsePostText = res + "PostTextResponse" + "fixture/PostTextResponse.proto" + lexRuntime + (Proxy :: Proxy PostText) diff --git a/test/Test/AWS/LexRuntime.hs b/test/Test/AWS/LexRuntime.hs new file mode 100644 --- /dev/null +++ b/test/Test/AWS/LexRuntime.hs @@ -0,0 +1,20 @@ +-- | +-- Module : Test.AWS.LexRuntime +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Test.AWS.LexRuntime + ( tests + , fixtures + ) where + +import Test.Tasty (TestTree) + +tests :: [TestTree] +tests = [] + +fixtures :: [TestTree] +fixtures = [] diff --git a/test/Test/AWS/LexRuntime/Internal.hs b/test/Test/AWS/LexRuntime/Internal.hs new file mode 100644 --- /dev/null +++ b/test/Test/AWS/LexRuntime/Internal.hs @@ -0,0 +1,9 @@ +-- | +-- Module : Test.AWS.LexRuntime.Internal +-- Copyright : (c) 2013-2016 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Test.AWS.LexRuntime.Internal where