diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,373 @@ +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. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,26 @@ +# Amazon CloudSearch SDK + +> _Warning:_ This is an experimental preview release which is still under heavy development and not intended for public consumption, _caveat emptor_! + +* [description](#description) +* [Contribute](#contribute) +* [Licence](#licence) + +## Description + +Amazon CloudSearch is a fully-managed service in the AWS Cloud that makes it simple and cost-effective to set up, manage, and scale a search solution for your website or application. Amazon CloudSearch supports 34 languages and popular search features such as highlighting, autocomplete, and geospatial search. + +Documentation is available via [Hackage](http://hackage.haskell.org/package/amazonka-cloudsearch) +and [AWS API Reference](http://docs.aws.amazon.com/cloudsearch/latest/developerguide/what-is-cloudsearch.html). + + +## 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-cloudsearch` is released under the [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/). 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-cloudsearch.cabal b/amazonka-cloudsearch.cabal new file mode 100644 --- /dev/null +++ b/amazonka-cloudsearch.cabal @@ -0,0 +1,69 @@ +name: amazonka-cloudsearch +version: 0.0.0 +synopsis: Amazon CloudSearch SDK. +homepage: https://github.com/brendanhay/amazonka +license: OtherLicense +license-file: LICENSE +author: Brendan Hay +maintainer: Brendan Hay +copyright: Copyright (c) 2013-2014 Brendan Hay +category: Network, AWS, Cloud +build-type: Simple +extra-source-files: README.md +cabal-version: >= 1.10 + +description: + Amazon CloudSearch is a fully-managed service in the AWS Cloud that + makes it simple and cost-effective to set up, manage, and scale a + search solution for your website or application. Amazon CloudSearch + supports 34 languages and popular search features such as highlighting, + autocomplete, and geospatial search. + . + /See:/ + . + /Warning:/ This is an experimental preview release which is still under + heavy development and not intended for public consumption, caveat emptor! + +source-repository head + type: git + location: git://github.com/brendanhay/amazonka.git + +library + default-language: Haskell2010 + hs-source-dirs: src gen + + ghc-options: -Wall + + exposed-modules: + Network.AWS.CloudSearch + , Network.AWS.CloudSearch.BuildSuggesters + , Network.AWS.CloudSearch.CreateDomain + , Network.AWS.CloudSearch.DefineAnalysisScheme + , Network.AWS.CloudSearch.DefineExpression + , Network.AWS.CloudSearch.DefineIndexField + , Network.AWS.CloudSearch.DefineSuggester + , Network.AWS.CloudSearch.DeleteAnalysisScheme + , Network.AWS.CloudSearch.DeleteDomain + , Network.AWS.CloudSearch.DeleteExpression + , Network.AWS.CloudSearch.DeleteIndexField + , Network.AWS.CloudSearch.DeleteSuggester + , Network.AWS.CloudSearch.DescribeAnalysisSchemes + , Network.AWS.CloudSearch.DescribeAvailabilityOptions + , Network.AWS.CloudSearch.DescribeDomains + , Network.AWS.CloudSearch.DescribeExpressions + , Network.AWS.CloudSearch.DescribeIndexFields + , Network.AWS.CloudSearch.DescribeScalingParameters + , Network.AWS.CloudSearch.DescribeServiceAccessPolicies + , Network.AWS.CloudSearch.DescribeSuggesters + , Network.AWS.CloudSearch.IndexDocuments + , Network.AWS.CloudSearch.ListDomainNames + , Network.AWS.CloudSearch.Types + , Network.AWS.CloudSearch.UpdateAvailabilityOptions + , Network.AWS.CloudSearch.UpdateScalingParameters + , Network.AWS.CloudSearch.UpdateServiceAccessPolicies + + other-modules: + + build-depends: + amazonka-core + , base >= 4.7 && < 5 diff --git a/gen/Network/AWS/CloudSearch.hs b/gen/Network/AWS/CloudSearch.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch.hs @@ -0,0 +1,68 @@ +-- Module : Network.AWS.CloudSearch +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Amazon CloudSearch is a fully-managed service in the AWS Cloud that makes +-- it simple and cost-effective to set up, manage, and scale a search solution +-- for your website or application. Amazon CloudSearch supports 34 languages +-- and popular search features such as highlighting, autocomplete, and +-- geospatial search. +module Network.AWS.CloudSearch + ( module Network.AWS.CloudSearch.BuildSuggesters + , module Network.AWS.CloudSearch.CreateDomain + , module Network.AWS.CloudSearch.DefineAnalysisScheme + , module Network.AWS.CloudSearch.DefineExpression + , module Network.AWS.CloudSearch.DefineIndexField + , module Network.AWS.CloudSearch.DefineSuggester + , module Network.AWS.CloudSearch.DeleteAnalysisScheme + , module Network.AWS.CloudSearch.DeleteDomain + , module Network.AWS.CloudSearch.DeleteExpression + , module Network.AWS.CloudSearch.DeleteIndexField + , module Network.AWS.CloudSearch.DeleteSuggester + , module Network.AWS.CloudSearch.DescribeAnalysisSchemes + , module Network.AWS.CloudSearch.DescribeAvailabilityOptions + , module Network.AWS.CloudSearch.DescribeDomains + , module Network.AWS.CloudSearch.DescribeExpressions + , module Network.AWS.CloudSearch.DescribeIndexFields + , module Network.AWS.CloudSearch.DescribeScalingParameters + , module Network.AWS.CloudSearch.DescribeServiceAccessPolicies + , module Network.AWS.CloudSearch.DescribeSuggesters + , module Network.AWS.CloudSearch.IndexDocuments + , module Network.AWS.CloudSearch.ListDomainNames + , module Network.AWS.CloudSearch.Types + , module Network.AWS.CloudSearch.UpdateAvailabilityOptions + , module Network.AWS.CloudSearch.UpdateScalingParameters + , module Network.AWS.CloudSearch.UpdateServiceAccessPolicies + ) where + +import Network.AWS.CloudSearch.BuildSuggesters +import Network.AWS.CloudSearch.CreateDomain +import Network.AWS.CloudSearch.DefineAnalysisScheme +import Network.AWS.CloudSearch.DefineExpression +import Network.AWS.CloudSearch.DefineIndexField +import Network.AWS.CloudSearch.DefineSuggester +import Network.AWS.CloudSearch.DeleteAnalysisScheme +import Network.AWS.CloudSearch.DeleteDomain +import Network.AWS.CloudSearch.DeleteExpression +import Network.AWS.CloudSearch.DeleteIndexField +import Network.AWS.CloudSearch.DeleteSuggester +import Network.AWS.CloudSearch.DescribeAnalysisSchemes +import Network.AWS.CloudSearch.DescribeAvailabilityOptions +import Network.AWS.CloudSearch.DescribeDomains +import Network.AWS.CloudSearch.DescribeExpressions +import Network.AWS.CloudSearch.DescribeIndexFields +import Network.AWS.CloudSearch.DescribeScalingParameters +import Network.AWS.CloudSearch.DescribeServiceAccessPolicies +import Network.AWS.CloudSearch.DescribeSuggesters +import Network.AWS.CloudSearch.IndexDocuments +import Network.AWS.CloudSearch.ListDomainNames +import Network.AWS.CloudSearch.Types +import Network.AWS.CloudSearch.UpdateAvailabilityOptions +import Network.AWS.CloudSearch.UpdateScalingParameters +import Network.AWS.CloudSearch.UpdateServiceAccessPolicies diff --git a/gen/Network/AWS/CloudSearch/BuildSuggesters.hs b/gen/Network/AWS/CloudSearch/BuildSuggesters.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/BuildSuggesters.hs @@ -0,0 +1,111 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.BuildSuggesters +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Indexes the search suggestions. For more information, see Configuring +-- Suggesters in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.BuildSuggesters + ( + -- * Request + BuildSuggesters + -- ** Request constructor + , buildSuggesters + -- ** Request lenses + , bsDomainName + + -- * Response + , BuildSuggestersResponse + -- ** Response constructor + , buildSuggestersResponse + -- ** Response lenses + , bsrFieldNames + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +newtype BuildSuggesters = BuildSuggesters + { _bsDomainName :: Text + } deriving (Eq, Ord, Show, Monoid, IsString) + +-- | 'BuildSuggesters' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'bsDomainName' @::@ 'Text' +-- +buildSuggesters :: Text -- ^ 'bsDomainName' + -> BuildSuggesters +buildSuggesters p1 = BuildSuggesters + { _bsDomainName = p1 + } + +bsDomainName :: Lens' BuildSuggesters Text +bsDomainName = lens _bsDomainName (\s a -> s { _bsDomainName = a }) + +newtype BuildSuggestersResponse = BuildSuggestersResponse + { _bsrFieldNames :: List "SuggesterNames" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList BuildSuggestersResponse where + type Item BuildSuggestersResponse = Text + + fromList = BuildSuggestersResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _bsrFieldNames + +-- | 'BuildSuggestersResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'bsrFieldNames' @::@ ['Text'] +-- +buildSuggestersResponse :: BuildSuggestersResponse +buildSuggestersResponse = BuildSuggestersResponse + { _bsrFieldNames = mempty + } + +bsrFieldNames :: Lens' BuildSuggestersResponse [Text] +bsrFieldNames = lens _bsrFieldNames (\s a -> s { _bsrFieldNames = a }) . _List + +instance ToPath BuildSuggesters where + toPath = const "/" + +instance ToQuery BuildSuggesters where + toQuery BuildSuggesters{..} = mconcat + [ "DomainName" =? _bsDomainName + ] + +instance ToHeaders BuildSuggesters + +instance AWSRequest BuildSuggesters where + type Sv BuildSuggesters = CloudSearch + type Rs BuildSuggesters = BuildSuggestersResponse + + request = post "BuildSuggesters" + response = xmlResponse + +instance FromXML BuildSuggestersResponse where + parseXML = withElement "BuildSuggestersResult" $ \x -> BuildSuggestersResponse + <$> x .@ "FieldNames" diff --git a/gen/Network/AWS/CloudSearch/CreateDomain.hs b/gen/Network/AWS/CloudSearch/CreateDomain.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/CreateDomain.hs @@ -0,0 +1,108 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.CreateDomain +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Creates a new search domain. For more information, see Creating a Search +-- Domain in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.CreateDomain + ( + -- * Request + CreateDomain + -- ** Request constructor + , createDomain + -- ** Request lenses + , cdDomainName + + -- * Response + , CreateDomainResponse + -- ** Response constructor + , createDomainResponse + -- ** Response lenses + , cdrDomainStatus + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +newtype CreateDomain = CreateDomain + { _cdDomainName :: Text + } deriving (Eq, Ord, Show, Monoid, IsString) + +-- | 'CreateDomain' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'cdDomainName' @::@ 'Text' +-- +createDomain :: Text -- ^ 'cdDomainName' + -> CreateDomain +createDomain p1 = CreateDomain + { _cdDomainName = p1 + } + +-- | A name for the domain you are creating. Allowed characters are a-z +-- (lower-case letters), 0-9, and hyphen (-). Domain names must start with a +-- letter or number and be at least 3 and no more than 28 characters long. +cdDomainName :: Lens' CreateDomain Text +cdDomainName = lens _cdDomainName (\s a -> s { _cdDomainName = a }) + +newtype CreateDomainResponse = CreateDomainResponse + { _cdrDomainStatus :: Maybe DomainStatus + } deriving (Eq, Show) + +-- | 'CreateDomainResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'cdrDomainStatus' @::@ 'Maybe' 'DomainStatus' +-- +createDomainResponse :: CreateDomainResponse +createDomainResponse = CreateDomainResponse + { _cdrDomainStatus = Nothing + } + +cdrDomainStatus :: Lens' CreateDomainResponse (Maybe DomainStatus) +cdrDomainStatus = lens _cdrDomainStatus (\s a -> s { _cdrDomainStatus = a }) + +instance ToPath CreateDomain where + toPath = const "/" + +instance ToQuery CreateDomain where + toQuery CreateDomain{..} = mconcat + [ "DomainName" =? _cdDomainName + ] + +instance ToHeaders CreateDomain + +instance AWSRequest CreateDomain where + type Sv CreateDomain = CloudSearch + type Rs CreateDomain = CreateDomainResponse + + request = post "CreateDomain" + response = xmlResponse + +instance FromXML CreateDomainResponse where + parseXML = withElement "CreateDomainResult" $ \x -> CreateDomainResponse + <$> x .@? "DomainStatus" diff --git a/gen/Network/AWS/CloudSearch/DefineAnalysisScheme.hs b/gen/Network/AWS/CloudSearch/DefineAnalysisScheme.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DefineAnalysisScheme.hs @@ -0,0 +1,120 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DefineAnalysisScheme +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Configures an analysis scheme that can be applied to a text or text-array +-- field to define language-specific text processing options. For more +-- information, see Configuring Analysis Schemes in the Amazon CloudSearch +-- Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DefineAnalysisScheme + ( + -- * Request + DefineAnalysisScheme + -- ** Request constructor + , defineAnalysisScheme + -- ** Request lenses + , das2AnalysisScheme + , das2DomainName + + -- * Response + , DefineAnalysisSchemeResponse + -- ** Response constructor + , defineAnalysisSchemeResponse + -- ** Response lenses + , dasr1AnalysisScheme + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DefineAnalysisScheme = DefineAnalysisScheme + { _das2AnalysisScheme :: AnalysisScheme + , _das2DomainName :: Text + } deriving (Eq, Show) + +-- | 'DefineAnalysisScheme' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'das2AnalysisScheme' @::@ 'AnalysisScheme' +-- +-- * 'das2DomainName' @::@ 'Text' +-- +defineAnalysisScheme :: Text -- ^ 'das2DomainName' + -> AnalysisScheme -- ^ 'das2AnalysisScheme' + -> DefineAnalysisScheme +defineAnalysisScheme p1 p2 = DefineAnalysisScheme + { _das2DomainName = p1 + , _das2AnalysisScheme = p2 + } + +das2AnalysisScheme :: Lens' DefineAnalysisScheme AnalysisScheme +das2AnalysisScheme = + lens _das2AnalysisScheme (\s a -> s { _das2AnalysisScheme = a }) + +das2DomainName :: Lens' DefineAnalysisScheme Text +das2DomainName = lens _das2DomainName (\s a -> s { _das2DomainName = a }) + +newtype DefineAnalysisSchemeResponse = DefineAnalysisSchemeResponse + { _dasr1AnalysisScheme :: AnalysisSchemeStatus + } deriving (Eq, Show) + +-- | 'DefineAnalysisSchemeResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dasr1AnalysisScheme' @::@ 'AnalysisSchemeStatus' +-- +defineAnalysisSchemeResponse :: AnalysisSchemeStatus -- ^ 'dasr1AnalysisScheme' + -> DefineAnalysisSchemeResponse +defineAnalysisSchemeResponse p1 = DefineAnalysisSchemeResponse + { _dasr1AnalysisScheme = p1 + } + +dasr1AnalysisScheme :: Lens' DefineAnalysisSchemeResponse AnalysisSchemeStatus +dasr1AnalysisScheme = + lens _dasr1AnalysisScheme (\s a -> s { _dasr1AnalysisScheme = a }) + +instance ToPath DefineAnalysisScheme where + toPath = const "/" + +instance ToQuery DefineAnalysisScheme where + toQuery DefineAnalysisScheme{..} = mconcat + [ "AnalysisScheme" =? _das2AnalysisScheme + , "DomainName" =? _das2DomainName + ] + +instance ToHeaders DefineAnalysisScheme + +instance AWSRequest DefineAnalysisScheme where + type Sv DefineAnalysisScheme = CloudSearch + type Rs DefineAnalysisScheme = DefineAnalysisSchemeResponse + + request = post "DefineAnalysisScheme" + response = xmlResponse + +instance FromXML DefineAnalysisSchemeResponse where + parseXML = withElement "DefineAnalysisSchemeResult" $ \x -> DefineAnalysisSchemeResponse + <$> x .@ "AnalysisScheme" diff --git a/gen/Network/AWS/CloudSearch/DefineExpression.hs b/gen/Network/AWS/CloudSearch/DefineExpression.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DefineExpression.hs @@ -0,0 +1,118 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DefineExpression +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Configures an Expression for the search domain. Used to create new +-- expressions and modify existing ones. If the expression exists, the new +-- configuration replaces the old one. For more information, see Configuring +-- Expressions in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DefineExpression + ( + -- * Request + DefineExpression + -- ** Request constructor + , defineExpression + -- ** Request lenses + , de1DomainName + , de1Expression + + -- * Response + , DefineExpressionResponse + -- ** Response constructor + , defineExpressionResponse + -- ** Response lenses + , derExpression + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DefineExpression = DefineExpression + { _de1DomainName :: Text + , _de1Expression :: Expression + } deriving (Eq, Show) + +-- | 'DefineExpression' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'de1DomainName' @::@ 'Text' +-- +-- * 'de1Expression' @::@ 'Expression' +-- +defineExpression :: Text -- ^ 'de1DomainName' + -> Expression -- ^ 'de1Expression' + -> DefineExpression +defineExpression p1 p2 = DefineExpression + { _de1DomainName = p1 + , _de1Expression = p2 + } + +de1DomainName :: Lens' DefineExpression Text +de1DomainName = lens _de1DomainName (\s a -> s { _de1DomainName = a }) + +de1Expression :: Lens' DefineExpression Expression +de1Expression = lens _de1Expression (\s a -> s { _de1Expression = a }) + +newtype DefineExpressionResponse = DefineExpressionResponse + { _derExpression :: ExpressionStatus + } deriving (Eq, Show) + +-- | 'DefineExpressionResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'derExpression' @::@ 'ExpressionStatus' +-- +defineExpressionResponse :: ExpressionStatus -- ^ 'derExpression' + -> DefineExpressionResponse +defineExpressionResponse p1 = DefineExpressionResponse + { _derExpression = p1 + } + +derExpression :: Lens' DefineExpressionResponse ExpressionStatus +derExpression = lens _derExpression (\s a -> s { _derExpression = a }) + +instance ToPath DefineExpression where + toPath = const "/" + +instance ToQuery DefineExpression where + toQuery DefineExpression{..} = mconcat + [ "DomainName" =? _de1DomainName + , "Expression" =? _de1Expression + ] + +instance ToHeaders DefineExpression + +instance AWSRequest DefineExpression where + type Sv DefineExpression = CloudSearch + type Rs DefineExpression = DefineExpressionResponse + + request = post "DefineExpression" + response = xmlResponse + +instance FromXML DefineExpressionResponse where + parseXML = withElement "DefineExpressionResult" $ \x -> DefineExpressionResponse + <$> x .@ "Expression" diff --git a/gen/Network/AWS/CloudSearch/DefineIndexField.hs b/gen/Network/AWS/CloudSearch/DefineIndexField.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DefineIndexField.hs @@ -0,0 +1,123 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DefineIndexField +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Configures an IndexField for the search domain. Used to create new fields +-- and modify existing ones. You must specify the name of the domain you are +-- configuring and an index field configuration. The index field configuration +-- specifies a unique name, the index field type, and the options you want to +-- configure for the field. The options you can specify depend on the +-- IndexFieldType. If the field exists, the new configuration replaces the old +-- one. For more information, see Configuring Index Fields in the Amazon +-- CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DefineIndexField + ( + -- * Request + DefineIndexField + -- ** Request constructor + , defineIndexField + -- ** Request lenses + , dif2DomainName + , dif2IndexField + + -- * Response + , DefineIndexFieldResponse + -- ** Response constructor + , defineIndexFieldResponse + -- ** Response lenses + , difr1IndexField + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DefineIndexField = DefineIndexField + { _dif2DomainName :: Text + , _dif2IndexField :: IndexField + } deriving (Eq, Show) + +-- | 'DefineIndexField' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dif2DomainName' @::@ 'Text' +-- +-- * 'dif2IndexField' @::@ 'IndexField' +-- +defineIndexField :: Text -- ^ 'dif2DomainName' + -> IndexField -- ^ 'dif2IndexField' + -> DefineIndexField +defineIndexField p1 p2 = DefineIndexField + { _dif2DomainName = p1 + , _dif2IndexField = p2 + } + +dif2DomainName :: Lens' DefineIndexField Text +dif2DomainName = lens _dif2DomainName (\s a -> s { _dif2DomainName = a }) + +-- | The index field and field options you want to configure. +dif2IndexField :: Lens' DefineIndexField IndexField +dif2IndexField = lens _dif2IndexField (\s a -> s { _dif2IndexField = a }) + +newtype DefineIndexFieldResponse = DefineIndexFieldResponse + { _difr1IndexField :: IndexFieldStatus + } deriving (Eq, Show) + +-- | 'DefineIndexFieldResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'difr1IndexField' @::@ 'IndexFieldStatus' +-- +defineIndexFieldResponse :: IndexFieldStatus -- ^ 'difr1IndexField' + -> DefineIndexFieldResponse +defineIndexFieldResponse p1 = DefineIndexFieldResponse + { _difr1IndexField = p1 + } + +difr1IndexField :: Lens' DefineIndexFieldResponse IndexFieldStatus +difr1IndexField = lens _difr1IndexField (\s a -> s { _difr1IndexField = a }) + +instance ToPath DefineIndexField where + toPath = const "/" + +instance ToQuery DefineIndexField where + toQuery DefineIndexField{..} = mconcat + [ "DomainName" =? _dif2DomainName + , "IndexField" =? _dif2IndexField + ] + +instance ToHeaders DefineIndexField + +instance AWSRequest DefineIndexField where + type Sv DefineIndexField = CloudSearch + type Rs DefineIndexField = DefineIndexFieldResponse + + request = post "DefineIndexField" + response = xmlResponse + +instance FromXML DefineIndexFieldResponse where + parseXML = withElement "DefineIndexFieldResult" $ \x -> DefineIndexFieldResponse + <$> x .@ "IndexField" diff --git a/gen/Network/AWS/CloudSearch/DefineSuggester.hs b/gen/Network/AWS/CloudSearch/DefineSuggester.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DefineSuggester.hs @@ -0,0 +1,120 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DefineSuggester +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Configures a suggester for a domain. A suggester enables you to display +-- possible matches before users finish typing their queries. When you +-- configure a suggester, you must specify the name of the text field you want +-- to search for possible matches and a unique name for the suggester. For +-- more information, see Getting Search Suggestions in the Amazon CloudSearch +-- Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DefineSuggester + ( + -- * Request + DefineSuggester + -- ** Request constructor + , defineSuggester + -- ** Request lenses + , ds2DomainName + , ds2Suggester + + -- * Response + , DefineSuggesterResponse + -- ** Response constructor + , defineSuggesterResponse + -- ** Response lenses + , dsrSuggester + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DefineSuggester = DefineSuggester + { _ds2DomainName :: Text + , _ds2Suggester :: Suggester + } deriving (Eq, Show) + +-- | 'DefineSuggester' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ds2DomainName' @::@ 'Text' +-- +-- * 'ds2Suggester' @::@ 'Suggester' +-- +defineSuggester :: Text -- ^ 'ds2DomainName' + -> Suggester -- ^ 'ds2Suggester' + -> DefineSuggester +defineSuggester p1 p2 = DefineSuggester + { _ds2DomainName = p1 + , _ds2Suggester = p2 + } + +ds2DomainName :: Lens' DefineSuggester Text +ds2DomainName = lens _ds2DomainName (\s a -> s { _ds2DomainName = a }) + +ds2Suggester :: Lens' DefineSuggester Suggester +ds2Suggester = lens _ds2Suggester (\s a -> s { _ds2Suggester = a }) + +newtype DefineSuggesterResponse = DefineSuggesterResponse + { _dsrSuggester :: SuggesterStatus + } deriving (Eq, Show) + +-- | 'DefineSuggesterResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsrSuggester' @::@ 'SuggesterStatus' +-- +defineSuggesterResponse :: SuggesterStatus -- ^ 'dsrSuggester' + -> DefineSuggesterResponse +defineSuggesterResponse p1 = DefineSuggesterResponse + { _dsrSuggester = p1 + } + +dsrSuggester :: Lens' DefineSuggesterResponse SuggesterStatus +dsrSuggester = lens _dsrSuggester (\s a -> s { _dsrSuggester = a }) + +instance ToPath DefineSuggester where + toPath = const "/" + +instance ToQuery DefineSuggester where + toQuery DefineSuggester{..} = mconcat + [ "DomainName" =? _ds2DomainName + , "Suggester" =? _ds2Suggester + ] + +instance ToHeaders DefineSuggester + +instance AWSRequest DefineSuggester where + type Sv DefineSuggester = CloudSearch + type Rs DefineSuggester = DefineSuggesterResponse + + request = post "DefineSuggester" + response = xmlResponse + +instance FromXML DefineSuggesterResponse where + parseXML = withElement "DefineSuggesterResult" $ \x -> DefineSuggesterResponse + <$> x .@ "Suggester" diff --git a/gen/Network/AWS/CloudSearch/DeleteAnalysisScheme.hs b/gen/Network/AWS/CloudSearch/DeleteAnalysisScheme.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DeleteAnalysisScheme.hs @@ -0,0 +1,120 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DeleteAnalysisScheme +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Deletes an analysis scheme. For more information, see Configuring Analysis +-- Schemes in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DeleteAnalysisScheme + ( + -- * Request + DeleteAnalysisScheme + -- ** Request constructor + , deleteAnalysisScheme + -- ** Request lenses + , dasAnalysisSchemeName + , dasDomainName + + -- * Response + , DeleteAnalysisSchemeResponse + -- ** Response constructor + , deleteAnalysisSchemeResponse + -- ** Response lenses + , dasrAnalysisScheme + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DeleteAnalysisScheme = DeleteAnalysisScheme + { _dasAnalysisSchemeName :: Text + , _dasDomainName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DeleteAnalysisScheme' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dasAnalysisSchemeName' @::@ 'Text' +-- +-- * 'dasDomainName' @::@ 'Text' +-- +deleteAnalysisScheme :: Text -- ^ 'dasDomainName' + -> Text -- ^ 'dasAnalysisSchemeName' + -> DeleteAnalysisScheme +deleteAnalysisScheme p1 p2 = DeleteAnalysisScheme + { _dasDomainName = p1 + , _dasAnalysisSchemeName = p2 + } + +-- | The name of the analysis scheme you want to delete. +dasAnalysisSchemeName :: Lens' DeleteAnalysisScheme Text +dasAnalysisSchemeName = + lens _dasAnalysisSchemeName (\s a -> s { _dasAnalysisSchemeName = a }) + +dasDomainName :: Lens' DeleteAnalysisScheme Text +dasDomainName = lens _dasDomainName (\s a -> s { _dasDomainName = a }) + +newtype DeleteAnalysisSchemeResponse = DeleteAnalysisSchemeResponse + { _dasrAnalysisScheme :: AnalysisSchemeStatus + } deriving (Eq, Show) + +-- | 'DeleteAnalysisSchemeResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dasrAnalysisScheme' @::@ 'AnalysisSchemeStatus' +-- +deleteAnalysisSchemeResponse :: AnalysisSchemeStatus -- ^ 'dasrAnalysisScheme' + -> DeleteAnalysisSchemeResponse +deleteAnalysisSchemeResponse p1 = DeleteAnalysisSchemeResponse + { _dasrAnalysisScheme = p1 + } + +-- | The status of the analysis scheme being deleted. +dasrAnalysisScheme :: Lens' DeleteAnalysisSchemeResponse AnalysisSchemeStatus +dasrAnalysisScheme = + lens _dasrAnalysisScheme (\s a -> s { _dasrAnalysisScheme = a }) + +instance ToPath DeleteAnalysisScheme where + toPath = const "/" + +instance ToQuery DeleteAnalysisScheme where + toQuery DeleteAnalysisScheme{..} = mconcat + [ "AnalysisSchemeName" =? _dasAnalysisSchemeName + , "DomainName" =? _dasDomainName + ] + +instance ToHeaders DeleteAnalysisScheme + +instance AWSRequest DeleteAnalysisScheme where + type Sv DeleteAnalysisScheme = CloudSearch + type Rs DeleteAnalysisScheme = DeleteAnalysisSchemeResponse + + request = post "DeleteAnalysisScheme" + response = xmlResponse + +instance FromXML DeleteAnalysisSchemeResponse where + parseXML = withElement "DeleteAnalysisSchemeResult" $ \x -> DeleteAnalysisSchemeResponse + <$> x .@ "AnalysisScheme" diff --git a/gen/Network/AWS/CloudSearch/DeleteDomain.hs b/gen/Network/AWS/CloudSearch/DeleteDomain.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DeleteDomain.hs @@ -0,0 +1,107 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DeleteDomain +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Permanently deletes a search domain and all of its data. Once a domain has +-- been deleted, it cannot be recovered. For more information, see Deleting a +-- Search Domain in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DeleteDomain + ( + -- * Request + DeleteDomain + -- ** Request constructor + , deleteDomain + -- ** Request lenses + , ddDomainName + + -- * Response + , DeleteDomainResponse + -- ** Response constructor + , deleteDomainResponse + -- ** Response lenses + , ddrDomainStatus + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +newtype DeleteDomain = DeleteDomain + { _ddDomainName :: Text + } deriving (Eq, Ord, Show, Monoid, IsString) + +-- | 'DeleteDomain' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ddDomainName' @::@ 'Text' +-- +deleteDomain :: Text -- ^ 'ddDomainName' + -> DeleteDomain +deleteDomain p1 = DeleteDomain + { _ddDomainName = p1 + } + +-- | The name of the domain you want to permanently delete. +ddDomainName :: Lens' DeleteDomain Text +ddDomainName = lens _ddDomainName (\s a -> s { _ddDomainName = a }) + +newtype DeleteDomainResponse = DeleteDomainResponse + { _ddrDomainStatus :: Maybe DomainStatus + } deriving (Eq, Show) + +-- | 'DeleteDomainResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ddrDomainStatus' @::@ 'Maybe' 'DomainStatus' +-- +deleteDomainResponse :: DeleteDomainResponse +deleteDomainResponse = DeleteDomainResponse + { _ddrDomainStatus = Nothing + } + +ddrDomainStatus :: Lens' DeleteDomainResponse (Maybe DomainStatus) +ddrDomainStatus = lens _ddrDomainStatus (\s a -> s { _ddrDomainStatus = a }) + +instance ToPath DeleteDomain where + toPath = const "/" + +instance ToQuery DeleteDomain where + toQuery DeleteDomain{..} = mconcat + [ "DomainName" =? _ddDomainName + ] + +instance ToHeaders DeleteDomain + +instance AWSRequest DeleteDomain where + type Sv DeleteDomain = CloudSearch + type Rs DeleteDomain = DeleteDomainResponse + + request = post "DeleteDomain" + response = xmlResponse + +instance FromXML DeleteDomainResponse where + parseXML = withElement "DeleteDomainResult" $ \x -> DeleteDomainResponse + <$> x .@? "DomainStatus" diff --git a/gen/Network/AWS/CloudSearch/DeleteExpression.hs b/gen/Network/AWS/CloudSearch/DeleteExpression.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DeleteExpression.hs @@ -0,0 +1,119 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DeleteExpression +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Removes an Expression from the search domain. For more information, see +-- Configuring Expressions in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DeleteExpression + ( + -- * Request + DeleteExpression + -- ** Request constructor + , deleteExpression + -- ** Request lenses + , de2DomainName + , de2ExpressionName + + -- * Response + , DeleteExpressionResponse + -- ** Response constructor + , deleteExpressionResponse + -- ** Response lenses + , der1Expression + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DeleteExpression = DeleteExpression + { _de2DomainName :: Text + , _de2ExpressionName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DeleteExpression' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'de2DomainName' @::@ 'Text' +-- +-- * 'de2ExpressionName' @::@ 'Text' +-- +deleteExpression :: Text -- ^ 'de2DomainName' + -> Text -- ^ 'de2ExpressionName' + -> DeleteExpression +deleteExpression p1 p2 = DeleteExpression + { _de2DomainName = p1 + , _de2ExpressionName = p2 + } + +de2DomainName :: Lens' DeleteExpression Text +de2DomainName = lens _de2DomainName (\s a -> s { _de2DomainName = a }) + +-- | The name of the Expression to delete. +de2ExpressionName :: Lens' DeleteExpression Text +de2ExpressionName = + lens _de2ExpressionName (\s a -> s { _de2ExpressionName = a }) + +newtype DeleteExpressionResponse = DeleteExpressionResponse + { _der1Expression :: ExpressionStatus + } deriving (Eq, Show) + +-- | 'DeleteExpressionResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'der1Expression' @::@ 'ExpressionStatus' +-- +deleteExpressionResponse :: ExpressionStatus -- ^ 'der1Expression' + -> DeleteExpressionResponse +deleteExpressionResponse p1 = DeleteExpressionResponse + { _der1Expression = p1 + } + +-- | The status of the expression being deleted. +der1Expression :: Lens' DeleteExpressionResponse ExpressionStatus +der1Expression = lens _der1Expression (\s a -> s { _der1Expression = a }) + +instance ToPath DeleteExpression where + toPath = const "/" + +instance ToQuery DeleteExpression where + toQuery DeleteExpression{..} = mconcat + [ "DomainName" =? _de2DomainName + , "ExpressionName" =? _de2ExpressionName + ] + +instance ToHeaders DeleteExpression + +instance AWSRequest DeleteExpression where + type Sv DeleteExpression = CloudSearch + type Rs DeleteExpression = DeleteExpressionResponse + + request = post "DeleteExpression" + response = xmlResponse + +instance FromXML DeleteExpressionResponse where + parseXML = withElement "DeleteExpressionResult" $ \x -> DeleteExpressionResponse + <$> x .@ "Expression" diff --git a/gen/Network/AWS/CloudSearch/DeleteIndexField.hs b/gen/Network/AWS/CloudSearch/DeleteIndexField.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DeleteIndexField.hs @@ -0,0 +1,120 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DeleteIndexField +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Removes an IndexField from the search domain. For more information, see +-- Configuring Index Fields in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DeleteIndexField + ( + -- * Request + DeleteIndexField + -- ** Request constructor + , deleteIndexField + -- ** Request lenses + , dif1DomainName + , dif1IndexFieldName + + -- * Response + , DeleteIndexFieldResponse + -- ** Response constructor + , deleteIndexFieldResponse + -- ** Response lenses + , difrIndexField + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DeleteIndexField = DeleteIndexField + { _dif1DomainName :: Text + , _dif1IndexFieldName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DeleteIndexField' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dif1DomainName' @::@ 'Text' +-- +-- * 'dif1IndexFieldName' @::@ 'Text' +-- +deleteIndexField :: Text -- ^ 'dif1DomainName' + -> Text -- ^ 'dif1IndexFieldName' + -> DeleteIndexField +deleteIndexField p1 p2 = DeleteIndexField + { _dif1DomainName = p1 + , _dif1IndexFieldName = p2 + } + +dif1DomainName :: Lens' DeleteIndexField Text +dif1DomainName = lens _dif1DomainName (\s a -> s { _dif1DomainName = a }) + +-- | The name of the index field your want to remove from the domain's +-- indexing options. +dif1IndexFieldName :: Lens' DeleteIndexField Text +dif1IndexFieldName = + lens _dif1IndexFieldName (\s a -> s { _dif1IndexFieldName = a }) + +newtype DeleteIndexFieldResponse = DeleteIndexFieldResponse + { _difrIndexField :: IndexFieldStatus + } deriving (Eq, Show) + +-- | 'DeleteIndexFieldResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'difrIndexField' @::@ 'IndexFieldStatus' +-- +deleteIndexFieldResponse :: IndexFieldStatus -- ^ 'difrIndexField' + -> DeleteIndexFieldResponse +deleteIndexFieldResponse p1 = DeleteIndexFieldResponse + { _difrIndexField = p1 + } + +-- | The status of the index field being deleted. +difrIndexField :: Lens' DeleteIndexFieldResponse IndexFieldStatus +difrIndexField = lens _difrIndexField (\s a -> s { _difrIndexField = a }) + +instance ToPath DeleteIndexField where + toPath = const "/" + +instance ToQuery DeleteIndexField where + toQuery DeleteIndexField{..} = mconcat + [ "DomainName" =? _dif1DomainName + , "IndexFieldName" =? _dif1IndexFieldName + ] + +instance ToHeaders DeleteIndexField + +instance AWSRequest DeleteIndexField where + type Sv DeleteIndexField = CloudSearch + type Rs DeleteIndexField = DeleteIndexFieldResponse + + request = post "DeleteIndexField" + response = xmlResponse + +instance FromXML DeleteIndexFieldResponse where + parseXML = withElement "DeleteIndexFieldResult" $ \x -> DeleteIndexFieldResponse + <$> x .@ "IndexField" diff --git a/gen/Network/AWS/CloudSearch/DeleteSuggester.hs b/gen/Network/AWS/CloudSearch/DeleteSuggester.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DeleteSuggester.hs @@ -0,0 +1,118 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DeleteSuggester +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Deletes a suggester. For more information, see Getting Search Suggestions +-- in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DeleteSuggester + ( + -- * Request + DeleteSuggester + -- ** Request constructor + , deleteSuggester + -- ** Request lenses + , ds3DomainName + , ds3SuggesterName + + -- * Response + , DeleteSuggesterResponse + -- ** Response constructor + , deleteSuggesterResponse + -- ** Response lenses + , dsr1Suggester + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DeleteSuggester = DeleteSuggester + { _ds3DomainName :: Text + , _ds3SuggesterName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DeleteSuggester' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ds3DomainName' @::@ 'Text' +-- +-- * 'ds3SuggesterName' @::@ 'Text' +-- +deleteSuggester :: Text -- ^ 'ds3DomainName' + -> Text -- ^ 'ds3SuggesterName' + -> DeleteSuggester +deleteSuggester p1 p2 = DeleteSuggester + { _ds3DomainName = p1 + , _ds3SuggesterName = p2 + } + +ds3DomainName :: Lens' DeleteSuggester Text +ds3DomainName = lens _ds3DomainName (\s a -> s { _ds3DomainName = a }) + +-- | Specifies the name of the suggester you want to delete. +ds3SuggesterName :: Lens' DeleteSuggester Text +ds3SuggesterName = lens _ds3SuggesterName (\s a -> s { _ds3SuggesterName = a }) + +newtype DeleteSuggesterResponse = DeleteSuggesterResponse + { _dsr1Suggester :: SuggesterStatus + } deriving (Eq, Show) + +-- | 'DeleteSuggesterResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsr1Suggester' @::@ 'SuggesterStatus' +-- +deleteSuggesterResponse :: SuggesterStatus -- ^ 'dsr1Suggester' + -> DeleteSuggesterResponse +deleteSuggesterResponse p1 = DeleteSuggesterResponse + { _dsr1Suggester = p1 + } + +-- | The status of the suggester being deleted. +dsr1Suggester :: Lens' DeleteSuggesterResponse SuggesterStatus +dsr1Suggester = lens _dsr1Suggester (\s a -> s { _dsr1Suggester = a }) + +instance ToPath DeleteSuggester where + toPath = const "/" + +instance ToQuery DeleteSuggester where + toQuery DeleteSuggester{..} = mconcat + [ "DomainName" =? _ds3DomainName + , "SuggesterName" =? _ds3SuggesterName + ] + +instance ToHeaders DeleteSuggester + +instance AWSRequest DeleteSuggester where + type Sv DeleteSuggester = CloudSearch + type Rs DeleteSuggester = DeleteSuggesterResponse + + request = post "DeleteSuggester" + response = xmlResponse + +instance FromXML DeleteSuggesterResponse where + parseXML = withElement "DeleteSuggesterResult" $ \x -> DeleteSuggesterResponse + <$> x .@ "Suggester" diff --git a/gen/Network/AWS/CloudSearch/DescribeAnalysisSchemes.hs b/gen/Network/AWS/CloudSearch/DescribeAnalysisSchemes.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeAnalysisSchemes.hs @@ -0,0 +1,143 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeAnalysisSchemes +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets the analysis schemes configured for a domain. An analysis scheme +-- defines language-specific text processing options for a text field. Can be +-- limited to specific analysis schemes by name. By default, shows all +-- analysis schemes and includes any pending changes to the configuration. Set +-- the Deployed option to true to show the active configuration and exclude +-- pending changes. For more information, see Configuring Analysis Schemes in +-- the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeAnalysisSchemes + ( + -- * Request + DescribeAnalysisSchemes + -- ** Request constructor + , describeAnalysisSchemes + -- ** Request lenses + , das1AnalysisSchemeNames + , das1Deployed + , das1DomainName + + -- * Response + , DescribeAnalysisSchemesResponse + -- ** Response constructor + , describeAnalysisSchemesResponse + -- ** Response lenses + , dasrAnalysisSchemes + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DescribeAnalysisSchemes = DescribeAnalysisSchemes + { _das1AnalysisSchemeNames :: List "SuggesterNames" Text + , _das1Deployed :: Maybe Bool + , _das1DomainName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DescribeAnalysisSchemes' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'das1AnalysisSchemeNames' @::@ ['Text'] +-- +-- * 'das1Deployed' @::@ 'Maybe' 'Bool' +-- +-- * 'das1DomainName' @::@ 'Text' +-- +describeAnalysisSchemes :: Text -- ^ 'das1DomainName' + -> DescribeAnalysisSchemes +describeAnalysisSchemes p1 = DescribeAnalysisSchemes + { _das1DomainName = p1 + , _das1AnalysisSchemeNames = mempty + , _das1Deployed = Nothing + } + +-- | The analysis schemes you want to describe. +das1AnalysisSchemeNames :: Lens' DescribeAnalysisSchemes [Text] +das1AnalysisSchemeNames = + lens _das1AnalysisSchemeNames (\s a -> s { _das1AnalysisSchemeNames = a }) + . _List + +-- | Whether to display the deployed configuration (true) or include any +-- pending changes (false). Defaults to false. +das1Deployed :: Lens' DescribeAnalysisSchemes (Maybe Bool) +das1Deployed = lens _das1Deployed (\s a -> s { _das1Deployed = a }) + +-- | The name of the domain you want to describe. +das1DomainName :: Lens' DescribeAnalysisSchemes Text +das1DomainName = lens _das1DomainName (\s a -> s { _das1DomainName = a }) + +newtype DescribeAnalysisSchemesResponse = DescribeAnalysisSchemesResponse + { _dasrAnalysisSchemes :: List "AnalysisSchemes" AnalysisSchemeStatus + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeAnalysisSchemesResponse where + type Item DescribeAnalysisSchemesResponse = AnalysisSchemeStatus + + fromList = DescribeAnalysisSchemesResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dasrAnalysisSchemes + +-- | 'DescribeAnalysisSchemesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dasrAnalysisSchemes' @::@ ['AnalysisSchemeStatus'] +-- +describeAnalysisSchemesResponse :: DescribeAnalysisSchemesResponse +describeAnalysisSchemesResponse = DescribeAnalysisSchemesResponse + { _dasrAnalysisSchemes = mempty + } + +-- | The analysis scheme descriptions. +dasrAnalysisSchemes :: Lens' DescribeAnalysisSchemesResponse [AnalysisSchemeStatus] +dasrAnalysisSchemes = + lens _dasrAnalysisSchemes (\s a -> s { _dasrAnalysisSchemes = a }) + . _List + +instance ToPath DescribeAnalysisSchemes where + toPath = const "/" + +instance ToQuery DescribeAnalysisSchemes where + toQuery DescribeAnalysisSchemes{..} = mconcat + [ "AnalysisSchemeNames" =? _das1AnalysisSchemeNames + , "Deployed" =? _das1Deployed + , "DomainName" =? _das1DomainName + ] + +instance ToHeaders DescribeAnalysisSchemes + +instance AWSRequest DescribeAnalysisSchemes where + type Sv DescribeAnalysisSchemes = CloudSearch + type Rs DescribeAnalysisSchemes = DescribeAnalysisSchemesResponse + + request = post "DescribeAnalysisSchemes" + response = xmlResponse + +instance FromXML DescribeAnalysisSchemesResponse where + parseXML = withElement "DescribeAnalysisSchemesResult" $ \x -> DescribeAnalysisSchemesResponse + <$> x .@ "AnalysisSchemes" diff --git a/gen/Network/AWS/CloudSearch/DescribeAvailabilityOptions.hs b/gen/Network/AWS/CloudSearch/DescribeAvailabilityOptions.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeAvailabilityOptions.hs @@ -0,0 +1,123 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeAvailabilityOptions +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets the availability options configured for a domain. By default, shows +-- the configuration with any pending changes. Set the Deployed option to true +-- to show the active configuration and exclude pending changes. For more +-- information, see Configuring Availability Options in the Amazon CloudSearch +-- Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeAvailabilityOptions + ( + -- * Request + DescribeAvailabilityOptions + -- ** Request constructor + , describeAvailabilityOptions + -- ** Request lenses + , daoDeployed + , daoDomainName + + -- * Response + , DescribeAvailabilityOptionsResponse + -- ** Response constructor + , describeAvailabilityOptionsResponse + -- ** Response lenses + , daorAvailabilityOptions + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DescribeAvailabilityOptions = DescribeAvailabilityOptions + { _daoDeployed :: Maybe Bool + , _daoDomainName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DescribeAvailabilityOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'daoDeployed' @::@ 'Maybe' 'Bool' +-- +-- * 'daoDomainName' @::@ 'Text' +-- +describeAvailabilityOptions :: Text -- ^ 'daoDomainName' + -> DescribeAvailabilityOptions +describeAvailabilityOptions p1 = DescribeAvailabilityOptions + { _daoDomainName = p1 + , _daoDeployed = Nothing + } + +-- | Whether to display the deployed configuration (true) or include any +-- pending changes (false). Defaults to false. +daoDeployed :: Lens' DescribeAvailabilityOptions (Maybe Bool) +daoDeployed = lens _daoDeployed (\s a -> s { _daoDeployed = a }) + +-- | The name of the domain you want to describe. +daoDomainName :: Lens' DescribeAvailabilityOptions Text +daoDomainName = lens _daoDomainName (\s a -> s { _daoDomainName = a }) + +newtype DescribeAvailabilityOptionsResponse = DescribeAvailabilityOptionsResponse + { _daorAvailabilityOptions :: Maybe AvailabilityOptionsStatus + } deriving (Eq, Show) + +-- | 'DescribeAvailabilityOptionsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'daorAvailabilityOptions' @::@ 'Maybe' 'AvailabilityOptionsStatus' +-- +describeAvailabilityOptionsResponse :: DescribeAvailabilityOptionsResponse +describeAvailabilityOptionsResponse = DescribeAvailabilityOptionsResponse + { _daorAvailabilityOptions = Nothing + } + +-- | The availability options configured for the domain. Indicates whether +-- Multi-AZ is enabled for the domain. +daorAvailabilityOptions :: Lens' DescribeAvailabilityOptionsResponse (Maybe AvailabilityOptionsStatus) +daorAvailabilityOptions = + lens _daorAvailabilityOptions (\s a -> s { _daorAvailabilityOptions = a }) + +instance ToPath DescribeAvailabilityOptions where + toPath = const "/" + +instance ToQuery DescribeAvailabilityOptions where + toQuery DescribeAvailabilityOptions{..} = mconcat + [ "Deployed" =? _daoDeployed + , "DomainName" =? _daoDomainName + ] + +instance ToHeaders DescribeAvailabilityOptions + +instance AWSRequest DescribeAvailabilityOptions where + type Sv DescribeAvailabilityOptions = CloudSearch + type Rs DescribeAvailabilityOptions = DescribeAvailabilityOptionsResponse + + request = post "DescribeAvailabilityOptions" + response = xmlResponse + +instance FromXML DescribeAvailabilityOptionsResponse where + parseXML = withElement "DescribeAvailabilityOptionsResult" $ \x -> DescribeAvailabilityOptionsResponse + <$> x .@? "AvailabilityOptions" diff --git a/gen/Network/AWS/CloudSearch/DescribeDomains.hs b/gen/Network/AWS/CloudSearch/DescribeDomains.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeDomains.hs @@ -0,0 +1,124 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeDomains +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets information about the search domains owned by this account. Can be +-- limited to specific domains. Shows all domains by default. To get the +-- number of searchable documents in a domain, use the console or submit a +-- matchall request to your domain's search endpoint: +-- q=matchall&amp;q.parser=structured&amp;size=0. For more +-- information, see Getting Information about a Search Domain in the Amazon +-- CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeDomains + ( + -- * Request + DescribeDomains + -- ** Request constructor + , describeDomains + -- ** Request lenses + , ddDomainNames + + -- * Response + , DescribeDomainsResponse + -- ** Response constructor + , describeDomainsResponse + -- ** Response lenses + , ddrDomainStatusList + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +newtype DescribeDomains = DescribeDomains + { _ddDomainNames :: List "DomainNames" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeDomains where + type Item DescribeDomains = Text + + fromList = DescribeDomains . GHC.Exts.fromList + toList = GHC.Exts.toList . _ddDomainNames + +-- | 'DescribeDomains' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ddDomainNames' @::@ ['Text'] +-- +describeDomains :: DescribeDomains +describeDomains = DescribeDomains + { _ddDomainNames = mempty + } + +-- | The names of the domains you want to include in the response. +ddDomainNames :: Lens' DescribeDomains [Text] +ddDomainNames = lens _ddDomainNames (\s a -> s { _ddDomainNames = a }) . _List + +newtype DescribeDomainsResponse = DescribeDomainsResponse + { _ddrDomainStatusList :: List "DomainStatusList" DomainStatus + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeDomainsResponse where + type Item DescribeDomainsResponse = DomainStatus + + fromList = DescribeDomainsResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _ddrDomainStatusList + +-- | 'DescribeDomainsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ddrDomainStatusList' @::@ ['DomainStatus'] +-- +describeDomainsResponse :: DescribeDomainsResponse +describeDomainsResponse = DescribeDomainsResponse + { _ddrDomainStatusList = mempty + } + +ddrDomainStatusList :: Lens' DescribeDomainsResponse [DomainStatus] +ddrDomainStatusList = + lens _ddrDomainStatusList (\s a -> s { _ddrDomainStatusList = a }) + . _List + +instance ToPath DescribeDomains where + toPath = const "/" + +instance ToQuery DescribeDomains where + toQuery DescribeDomains{..} = mconcat + [ "DomainNames" =? _ddDomainNames + ] + +instance ToHeaders DescribeDomains + +instance AWSRequest DescribeDomains where + type Sv DescribeDomains = CloudSearch + type Rs DescribeDomains = DescribeDomainsResponse + + request = post "DescribeDomains" + response = xmlResponse + +instance FromXML DescribeDomainsResponse where + parseXML = withElement "DescribeDomainsResult" $ \x -> DescribeDomainsResponse + <$> x .@ "DomainStatusList" diff --git a/gen/Network/AWS/CloudSearch/DescribeExpressions.hs b/gen/Network/AWS/CloudSearch/DescribeExpressions.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeExpressions.hs @@ -0,0 +1,141 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeExpressions +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets the expressions configured for the search domain. Can be limited to +-- specific expressions by name. By default, shows all expressions and +-- includes any pending changes to the configuration. Set the Deployed option +-- to true to show the active configuration and exclude pending changes. For +-- more information, see Configuring Expressions in the Amazon CloudSearch +-- Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeExpressions + ( + -- * Request + DescribeExpressions + -- ** Request constructor + , describeExpressions + -- ** Request lenses + , deDeployed + , deDomainName + , deExpressionNames + + -- * Response + , DescribeExpressionsResponse + -- ** Response constructor + , describeExpressionsResponse + -- ** Response lenses + , derExpressions + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DescribeExpressions = DescribeExpressions + { _deDeployed :: Maybe Bool + , _deDomainName :: Text + , _deExpressionNames :: List "SuggesterNames" Text + } deriving (Eq, Ord, Show) + +-- | 'DescribeExpressions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'deDeployed' @::@ 'Maybe' 'Bool' +-- +-- * 'deDomainName' @::@ 'Text' +-- +-- * 'deExpressionNames' @::@ ['Text'] +-- +describeExpressions :: Text -- ^ 'deDomainName' + -> DescribeExpressions +describeExpressions p1 = DescribeExpressions + { _deDomainName = p1 + , _deExpressionNames = mempty + , _deDeployed = Nothing + } + +-- | Whether to display the deployed configuration (true) or include any +-- pending changes (false). Defaults to false. +deDeployed :: Lens' DescribeExpressions (Maybe Bool) +deDeployed = lens _deDeployed (\s a -> s { _deDeployed = a }) + +-- | The name of the domain you want to describe. +deDomainName :: Lens' DescribeExpressions Text +deDomainName = lens _deDomainName (\s a -> s { _deDomainName = a }) + +-- | Limits the DescribeExpressions response to the specified expressions. If +-- not specified, all expressions are shown. +deExpressionNames :: Lens' DescribeExpressions [Text] +deExpressionNames = + lens _deExpressionNames (\s a -> s { _deExpressionNames = a }) + . _List + +newtype DescribeExpressionsResponse = DescribeExpressionsResponse + { _derExpressions :: List "Expressions" ExpressionStatus + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeExpressionsResponse where + type Item DescribeExpressionsResponse = ExpressionStatus + + fromList = DescribeExpressionsResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _derExpressions + +-- | 'DescribeExpressionsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'derExpressions' @::@ ['ExpressionStatus'] +-- +describeExpressionsResponse :: DescribeExpressionsResponse +describeExpressionsResponse = DescribeExpressionsResponse + { _derExpressions = mempty + } + +-- | The expressions configured for the domain. +derExpressions :: Lens' DescribeExpressionsResponse [ExpressionStatus] +derExpressions = lens _derExpressions (\s a -> s { _derExpressions = a }) . _List + +instance ToPath DescribeExpressions where + toPath = const "/" + +instance ToQuery DescribeExpressions where + toQuery DescribeExpressions{..} = mconcat + [ "Deployed" =? _deDeployed + , "DomainName" =? _deDomainName + , "ExpressionNames" =? _deExpressionNames + ] + +instance ToHeaders DescribeExpressions + +instance AWSRequest DescribeExpressions where + type Sv DescribeExpressions = CloudSearch + type Rs DescribeExpressions = DescribeExpressionsResponse + + request = post "DescribeExpressions" + response = xmlResponse + +instance FromXML DescribeExpressionsResponse where + parseXML = withElement "DescribeExpressionsResult" $ \x -> DescribeExpressionsResponse + <$> x .@ "Expressions" diff --git a/gen/Network/AWS/CloudSearch/DescribeIndexFields.hs b/gen/Network/AWS/CloudSearch/DescribeIndexFields.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeIndexFields.hs @@ -0,0 +1,139 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeIndexFields +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets information about the index fields configured for the search domain. +-- Can be limited to specific fields by name. By default, shows all fields and +-- includes any pending changes to the configuration. Set the Deployed option +-- to true to show the active configuration and exclude pending changes. For +-- more information, see Getting Domain Information in the Amazon CloudSearch +-- Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeIndexFields + ( + -- * Request + DescribeIndexFields + -- ** Request constructor + , describeIndexFields + -- ** Request lenses + , difDeployed + , difDomainName + , difFieldNames + + -- * Response + , DescribeIndexFieldsResponse + -- ** Response constructor + , describeIndexFieldsResponse + -- ** Response lenses + , difrIndexFields + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DescribeIndexFields = DescribeIndexFields + { _difDeployed :: Maybe Bool + , _difDomainName :: Text + , _difFieldNames :: List "SuggesterNames" Text + } deriving (Eq, Ord, Show) + +-- | 'DescribeIndexFields' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'difDeployed' @::@ 'Maybe' 'Bool' +-- +-- * 'difDomainName' @::@ 'Text' +-- +-- * 'difFieldNames' @::@ ['Text'] +-- +describeIndexFields :: Text -- ^ 'difDomainName' + -> DescribeIndexFields +describeIndexFields p1 = DescribeIndexFields + { _difDomainName = p1 + , _difFieldNames = mempty + , _difDeployed = Nothing + } + +-- | Whether to display the deployed configuration (true) or include any +-- pending changes (false). Defaults to false. +difDeployed :: Lens' DescribeIndexFields (Maybe Bool) +difDeployed = lens _difDeployed (\s a -> s { _difDeployed = a }) + +-- | The name of the domain you want to describe. +difDomainName :: Lens' DescribeIndexFields Text +difDomainName = lens _difDomainName (\s a -> s { _difDomainName = a }) + +-- | A list of the index fields you want to describe. If not specified, +-- information is returned for all configured index fields. +difFieldNames :: Lens' DescribeIndexFields [Text] +difFieldNames = lens _difFieldNames (\s a -> s { _difFieldNames = a }) . _List + +newtype DescribeIndexFieldsResponse = DescribeIndexFieldsResponse + { _difrIndexFields :: List "IndexFields" IndexFieldStatus + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeIndexFieldsResponse where + type Item DescribeIndexFieldsResponse = IndexFieldStatus + + fromList = DescribeIndexFieldsResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _difrIndexFields + +-- | 'DescribeIndexFieldsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'difrIndexFields' @::@ ['IndexFieldStatus'] +-- +describeIndexFieldsResponse :: DescribeIndexFieldsResponse +describeIndexFieldsResponse = DescribeIndexFieldsResponse + { _difrIndexFields = mempty + } + +-- | The index fields configured for the domain. +difrIndexFields :: Lens' DescribeIndexFieldsResponse [IndexFieldStatus] +difrIndexFields = lens _difrIndexFields (\s a -> s { _difrIndexFields = a }) . _List + +instance ToPath DescribeIndexFields where + toPath = const "/" + +instance ToQuery DescribeIndexFields where + toQuery DescribeIndexFields{..} = mconcat + [ "Deployed" =? _difDeployed + , "DomainName" =? _difDomainName + , "FieldNames" =? _difFieldNames + ] + +instance ToHeaders DescribeIndexFields + +instance AWSRequest DescribeIndexFields where + type Sv DescribeIndexFields = CloudSearch + type Rs DescribeIndexFields = DescribeIndexFieldsResponse + + request = post "DescribeIndexFields" + response = xmlResponse + +instance FromXML DescribeIndexFieldsResponse where + parseXML = withElement "DescribeIndexFieldsResult" $ \x -> DescribeIndexFieldsResponse + <$> x .@ "IndexFields" diff --git a/gen/Network/AWS/CloudSearch/DescribeScalingParameters.hs b/gen/Network/AWS/CloudSearch/DescribeScalingParameters.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeScalingParameters.hs @@ -0,0 +1,109 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeScalingParameters +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets the scaling parameters configured for a domain. A domain's scaling +-- parameters specify the desired search instance type and replication count. +-- For more information, see Configuring Scaling Options in the Amazon +-- CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeScalingParameters + ( + -- * Request + DescribeScalingParameters + -- ** Request constructor + , describeScalingParameters + -- ** Request lenses + , dspDomainName + + -- * Response + , DescribeScalingParametersResponse + -- ** Response constructor + , describeScalingParametersResponse + -- ** Response lenses + , dsprScalingParameters + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +newtype DescribeScalingParameters = DescribeScalingParameters + { _dspDomainName :: Text + } deriving (Eq, Ord, Show, Monoid, IsString) + +-- | 'DescribeScalingParameters' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dspDomainName' @::@ 'Text' +-- +describeScalingParameters :: Text -- ^ 'dspDomainName' + -> DescribeScalingParameters +describeScalingParameters p1 = DescribeScalingParameters + { _dspDomainName = p1 + } + +dspDomainName :: Lens' DescribeScalingParameters Text +dspDomainName = lens _dspDomainName (\s a -> s { _dspDomainName = a }) + +newtype DescribeScalingParametersResponse = DescribeScalingParametersResponse + { _dsprScalingParameters :: ScalingParametersStatus + } deriving (Eq, Show) + +-- | 'DescribeScalingParametersResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsprScalingParameters' @::@ 'ScalingParametersStatus' +-- +describeScalingParametersResponse :: ScalingParametersStatus -- ^ 'dsprScalingParameters' + -> DescribeScalingParametersResponse +describeScalingParametersResponse p1 = DescribeScalingParametersResponse + { _dsprScalingParameters = p1 + } + +dsprScalingParameters :: Lens' DescribeScalingParametersResponse ScalingParametersStatus +dsprScalingParameters = + lens _dsprScalingParameters (\s a -> s { _dsprScalingParameters = a }) + +instance ToPath DescribeScalingParameters where + toPath = const "/" + +instance ToQuery DescribeScalingParameters where + toQuery DescribeScalingParameters{..} = mconcat + [ "DomainName" =? _dspDomainName + ] + +instance ToHeaders DescribeScalingParameters + +instance AWSRequest DescribeScalingParameters where + type Sv DescribeScalingParameters = CloudSearch + type Rs DescribeScalingParameters = DescribeScalingParametersResponse + + request = post "DescribeScalingParameters" + response = xmlResponse + +instance FromXML DescribeScalingParametersResponse where + parseXML = withElement "DescribeScalingParametersResult" $ \x -> DescribeScalingParametersResponse + <$> x .@ "ScalingParameters" diff --git a/gen/Network/AWS/CloudSearch/DescribeServiceAccessPolicies.hs b/gen/Network/AWS/CloudSearch/DescribeServiceAccessPolicies.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeServiceAccessPolicies.hs @@ -0,0 +1,124 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeServiceAccessPolicies +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets information about the access policies that control access to the +-- domain's document and search endpoints. By default, shows the configuration +-- with any pending changes. Set the Deployed option to true to show the +-- active configuration and exclude pending changes. For more information, see +-- Configuring Access for a Search Domain in the Amazon CloudSearch Developer +-- Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeServiceAccessPolicies + ( + -- * Request + DescribeServiceAccessPolicies + -- ** Request constructor + , describeServiceAccessPolicies + -- ** Request lenses + , dsapDeployed + , dsapDomainName + + -- * Response + , DescribeServiceAccessPoliciesResponse + -- ** Response constructor + , describeServiceAccessPoliciesResponse + -- ** Response lenses + , dsaprAccessPolicies + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DescribeServiceAccessPolicies = DescribeServiceAccessPolicies + { _dsapDeployed :: Maybe Bool + , _dsapDomainName :: Text + } deriving (Eq, Ord, Show) + +-- | 'DescribeServiceAccessPolicies' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsapDeployed' @::@ 'Maybe' 'Bool' +-- +-- * 'dsapDomainName' @::@ 'Text' +-- +describeServiceAccessPolicies :: Text -- ^ 'dsapDomainName' + -> DescribeServiceAccessPolicies +describeServiceAccessPolicies p1 = DescribeServiceAccessPolicies + { _dsapDomainName = p1 + , _dsapDeployed = Nothing + } + +-- | Whether to display the deployed configuration (true) or include any +-- pending changes (false). Defaults to false. +dsapDeployed :: Lens' DescribeServiceAccessPolicies (Maybe Bool) +dsapDeployed = lens _dsapDeployed (\s a -> s { _dsapDeployed = a }) + +-- | The name of the domain you want to describe. +dsapDomainName :: Lens' DescribeServiceAccessPolicies Text +dsapDomainName = lens _dsapDomainName (\s a -> s { _dsapDomainName = a }) + +newtype DescribeServiceAccessPoliciesResponse = DescribeServiceAccessPoliciesResponse + { _dsaprAccessPolicies :: AccessPoliciesStatus + } deriving (Eq, Show) + +-- | 'DescribeServiceAccessPoliciesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsaprAccessPolicies' @::@ 'AccessPoliciesStatus' +-- +describeServiceAccessPoliciesResponse :: AccessPoliciesStatus -- ^ 'dsaprAccessPolicies' + -> DescribeServiceAccessPoliciesResponse +describeServiceAccessPoliciesResponse p1 = DescribeServiceAccessPoliciesResponse + { _dsaprAccessPolicies = p1 + } + +-- | The access rules configured for the domain specified in the request. +dsaprAccessPolicies :: Lens' DescribeServiceAccessPoliciesResponse AccessPoliciesStatus +dsaprAccessPolicies = + lens _dsaprAccessPolicies (\s a -> s { _dsaprAccessPolicies = a }) + +instance ToPath DescribeServiceAccessPolicies where + toPath = const "/" + +instance ToQuery DescribeServiceAccessPolicies where + toQuery DescribeServiceAccessPolicies{..} = mconcat + [ "Deployed" =? _dsapDeployed + , "DomainName" =? _dsapDomainName + ] + +instance ToHeaders DescribeServiceAccessPolicies + +instance AWSRequest DescribeServiceAccessPolicies where + type Sv DescribeServiceAccessPolicies = CloudSearch + type Rs DescribeServiceAccessPolicies = DescribeServiceAccessPoliciesResponse + + request = post "DescribeServiceAccessPolicies" + response = xmlResponse + +instance FromXML DescribeServiceAccessPoliciesResponse where + parseXML = withElement "DescribeServiceAccessPoliciesResult" $ \x -> DescribeServiceAccessPoliciesResponse + <$> x .@ "AccessPolicies" diff --git a/gen/Network/AWS/CloudSearch/DescribeSuggesters.hs b/gen/Network/AWS/CloudSearch/DescribeSuggesters.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/DescribeSuggesters.hs @@ -0,0 +1,141 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.DescribeSuggesters +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Gets the suggesters configured for a domain. A suggester enables you to +-- display possible matches before users finish typing their queries. Can be +-- limited to specific suggesters by name. By default, shows all suggesters +-- and includes any pending changes to the configuration. Set the Deployed +-- option to true to show the active configuration and exclude pending +-- changes. For more information, see Getting Search Suggestions in the Amazon +-- CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.DescribeSuggesters + ( + -- * Request + DescribeSuggesters + -- ** Request constructor + , describeSuggesters + -- ** Request lenses + , ds1Deployed + , ds1DomainName + , ds1SuggesterNames + + -- * Response + , DescribeSuggestersResponse + -- ** Response constructor + , describeSuggestersResponse + -- ** Response lenses + , dsrSuggesters + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data DescribeSuggesters = DescribeSuggesters + { _ds1Deployed :: Maybe Bool + , _ds1DomainName :: Text + , _ds1SuggesterNames :: List "SuggesterNames" Text + } deriving (Eq, Ord, Show) + +-- | 'DescribeSuggesters' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ds1Deployed' @::@ 'Maybe' 'Bool' +-- +-- * 'ds1DomainName' @::@ 'Text' +-- +-- * 'ds1SuggesterNames' @::@ ['Text'] +-- +describeSuggesters :: Text -- ^ 'ds1DomainName' + -> DescribeSuggesters +describeSuggesters p1 = DescribeSuggesters + { _ds1DomainName = p1 + , _ds1SuggesterNames = mempty + , _ds1Deployed = Nothing + } + +-- | Whether to display the deployed configuration (true) or include any +-- pending changes (false). Defaults to false. +ds1Deployed :: Lens' DescribeSuggesters (Maybe Bool) +ds1Deployed = lens _ds1Deployed (\s a -> s { _ds1Deployed = a }) + +-- | The name of the domain you want to describe. +ds1DomainName :: Lens' DescribeSuggesters Text +ds1DomainName = lens _ds1DomainName (\s a -> s { _ds1DomainName = a }) + +-- | The suggesters you want to describe. +ds1SuggesterNames :: Lens' DescribeSuggesters [Text] +ds1SuggesterNames = + lens _ds1SuggesterNames (\s a -> s { _ds1SuggesterNames = a }) + . _List + +newtype DescribeSuggestersResponse = DescribeSuggestersResponse + { _dsrSuggesters :: List "Suggesters" SuggesterStatus + } deriving (Eq, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList DescribeSuggestersResponse where + type Item DescribeSuggestersResponse = SuggesterStatus + + fromList = DescribeSuggestersResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _dsrSuggesters + +-- | 'DescribeSuggestersResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsrSuggesters' @::@ ['SuggesterStatus'] +-- +describeSuggestersResponse :: DescribeSuggestersResponse +describeSuggestersResponse = DescribeSuggestersResponse + { _dsrSuggesters = mempty + } + +-- | The suggesters configured for the domain specified in the request. +dsrSuggesters :: Lens' DescribeSuggestersResponse [SuggesterStatus] +dsrSuggesters = lens _dsrSuggesters (\s a -> s { _dsrSuggesters = a }) . _List + +instance ToPath DescribeSuggesters where + toPath = const "/" + +instance ToQuery DescribeSuggesters where + toQuery DescribeSuggesters{..} = mconcat + [ "Deployed" =? _ds1Deployed + , "DomainName" =? _ds1DomainName + , "SuggesterNames" =? _ds1SuggesterNames + ] + +instance ToHeaders DescribeSuggesters + +instance AWSRequest DescribeSuggesters where + type Sv DescribeSuggesters = CloudSearch + type Rs DescribeSuggesters = DescribeSuggestersResponse + + request = post "DescribeSuggesters" + response = xmlResponse + +instance FromXML DescribeSuggestersResponse where + parseXML = withElement "DescribeSuggestersResult" $ \x -> DescribeSuggestersResponse + <$> x .@ "Suggesters" diff --git a/gen/Network/AWS/CloudSearch/IndexDocuments.hs b/gen/Network/AWS/CloudSearch/IndexDocuments.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/IndexDocuments.hs @@ -0,0 +1,113 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.IndexDocuments +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Tells the search domain to start indexing its documents using the latest +-- indexing options. This operation must be invoked to activate options whose +-- OptionStatus is RequiresIndexDocuments. +-- +-- +module Network.AWS.CloudSearch.IndexDocuments + ( + -- * Request + IndexDocuments + -- ** Request constructor + , indexDocuments + -- ** Request lenses + , idDomainName + + -- * Response + , IndexDocumentsResponse + -- ** Response constructor + , indexDocumentsResponse + -- ** Response lenses + , idrFieldNames + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +newtype IndexDocuments = IndexDocuments + { _idDomainName :: Text + } deriving (Eq, Ord, Show, Monoid, IsString) + +-- | 'IndexDocuments' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'idDomainName' @::@ 'Text' +-- +indexDocuments :: Text -- ^ 'idDomainName' + -> IndexDocuments +indexDocuments p1 = IndexDocuments + { _idDomainName = p1 + } + +idDomainName :: Lens' IndexDocuments Text +idDomainName = lens _idDomainName (\s a -> s { _idDomainName = a }) + +newtype IndexDocumentsResponse = IndexDocumentsResponse + { _idrFieldNames :: List "SuggesterNames" Text + } deriving (Eq, Ord, Show, Monoid, Semigroup) + +instance GHC.Exts.IsList IndexDocumentsResponse where + type Item IndexDocumentsResponse = Text + + fromList = IndexDocumentsResponse . GHC.Exts.fromList + toList = GHC.Exts.toList . _idrFieldNames + +-- | 'IndexDocumentsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'idrFieldNames' @::@ ['Text'] +-- +indexDocumentsResponse :: IndexDocumentsResponse +indexDocumentsResponse = IndexDocumentsResponse + { _idrFieldNames = mempty + } + +-- | The names of the fields that are currently being indexed. +idrFieldNames :: Lens' IndexDocumentsResponse [Text] +idrFieldNames = lens _idrFieldNames (\s a -> s { _idrFieldNames = a }) . _List + +instance ToPath IndexDocuments where + toPath = const "/" + +instance ToQuery IndexDocuments where + toQuery IndexDocuments{..} = mconcat + [ "DomainName" =? _idDomainName + ] + +instance ToHeaders IndexDocuments + +instance AWSRequest IndexDocuments where + type Sv IndexDocuments = CloudSearch + type Rs IndexDocuments = IndexDocumentsResponse + + request = post "IndexDocuments" + response = xmlResponse + +instance FromXML IndexDocumentsResponse where + parseXML = withElement "IndexDocumentsResult" $ \x -> IndexDocumentsResponse + <$> x .@ "FieldNames" diff --git a/gen/Network/AWS/CloudSearch/ListDomainNames.hs b/gen/Network/AWS/CloudSearch/ListDomainNames.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/ListDomainNames.hs @@ -0,0 +1,89 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.ListDomainNames +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Lists all search domains owned by an account. +-- +-- +module Network.AWS.CloudSearch.ListDomainNames + ( + -- * Request + ListDomainNames + -- ** Request constructor + , listDomainNames + + -- * Response + , ListDomainNamesResponse + -- ** Response constructor + , listDomainNamesResponse + -- ** Response lenses + , ldnrDomainNames + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data ListDomainNames = ListDomainNames + deriving (Eq, Ord, Show, Generic) + +-- | 'ListDomainNames' constructor. +listDomainNames :: ListDomainNames +listDomainNames = ListDomainNames + +newtype ListDomainNamesResponse = ListDomainNamesResponse + { _ldnrDomainNames :: EMap "entry" "key" "value" Text Text + } deriving (Eq, Show, Monoid, Semigroup) + +-- | 'ListDomainNamesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ldnrDomainNames' @::@ 'HashMap' 'Text' 'Text' +-- +listDomainNamesResponse :: ListDomainNamesResponse +listDomainNamesResponse = ListDomainNamesResponse + { _ldnrDomainNames = mempty + } + +-- | The names of the search domains owned by an account. +ldnrDomainNames :: Lens' ListDomainNamesResponse (HashMap Text Text) +ldnrDomainNames = lens _ldnrDomainNames (\s a -> s { _ldnrDomainNames = a }) . _EMap + +instance ToPath ListDomainNames where + toPath = const "/" + +instance ToQuery ListDomainNames where + toQuery = const mempty + +instance ToHeaders ListDomainNames + +instance AWSRequest ListDomainNames where + type Sv ListDomainNames = CloudSearch + type Rs ListDomainNames = ListDomainNamesResponse + + request = post "ListDomainNames" + response = xmlResponse + +instance FromXML ListDomainNamesResponse where + parseXML = withElement "ListDomainNamesResult" $ \x -> ListDomainNamesResponse + <$> x .@ "DomainNames" diff --git a/gen/Network/AWS/CloudSearch/Types.hs b/gen/Network/AWS/CloudSearch/Types.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/Types.hs @@ -0,0 +1,2479 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.Types +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +module Network.AWS.CloudSearch.Types + ( + -- * Service + CloudSearch + -- ** Error + , RESTError + -- ** XML + , ns + + -- * DomainStatus + , DomainStatus + , domainStatus + , dsARN + , dsCreated + , dsDeleted + , dsDocService + , dsDomainId + , dsDomainName + , dsLimits + , dsProcessing + , dsRequiresIndexDocuments + , dsSearchInstanceCount + , dsSearchInstanceType + , dsSearchPartitionCount + , dsSearchService + + -- * DocumentSuggesterOptions + , DocumentSuggesterOptions + , documentSuggesterOptions + , dsoFuzzyMatching + , dsoSortExpression + , dsoSourceField + + -- * DoubleArrayOptions + , DoubleArrayOptions + , doubleArrayOptions + , daoDefaultValue + , daoFacetEnabled + , daoReturnEnabled + , daoSearchEnabled + , daoSourceFields + + -- * IndexField + , IndexField + , indexField + , ifDateArrayOptions + , ifDateOptions + , ifDoubleArrayOptions + , ifDoubleOptions + , ifIndexFieldName + , ifIndexFieldType + , ifIntArrayOptions + , ifIntOptions + , ifLatLonOptions + , ifLiteralArrayOptions + , ifLiteralOptions + , ifTextArrayOptions + , ifTextOptions + + -- * DateOptions + , DateOptions + , dateOptions + , doDefaultValue + , doFacetEnabled + , doReturnEnabled + , doSearchEnabled + , doSortEnabled + , doSourceField + + -- * OptionState + , OptionState (..) + + -- * TextArrayOptions + , TextArrayOptions + , textArrayOptions + , taoAnalysisScheme + , taoDefaultValue + , taoHighlightEnabled + , taoReturnEnabled + , taoSourceFields + + -- * AlgorithmicStemming + , AlgorithmicStemming (..) + + -- * AnalysisScheme + , AnalysisScheme + , analysisScheme + , asAnalysisOptions + , asAnalysisSchemeLanguage + , asAnalysisSchemeName + + -- * ScalingParameters + , ScalingParameters + , scalingParameters + , spDesiredInstanceType + , spDesiredPartitionCount + , spDesiredReplicationCount + + -- * AnalysisOptions + , AnalysisOptions + , analysisOptions + , aoAlgorithmicStemming + , aoJapaneseTokenizationDictionary + , aoStemmingDictionary + , aoStopwords + , aoSynonyms + + -- * DoubleOptions + , DoubleOptions + , doubleOptions + , do1DefaultValue + , do1FacetEnabled + , do1ReturnEnabled + , do1SearchEnabled + , do1SortEnabled + , do1SourceField + + -- * TextOptions + , TextOptions + , textOptions + , toAnalysisScheme + , toDefaultValue + , toHighlightEnabled + , toReturnEnabled + , toSortEnabled + , toSourceField + + -- * AvailabilityOptionsStatus + , AvailabilityOptionsStatus + , availabilityOptionsStatus + , aosOptions + , aosStatus + + -- * IndexFieldStatus + , IndexFieldStatus + , indexFieldStatus + , ifsOptions + , ifsStatus + + -- * ScalingParametersStatus + , ScalingParametersStatus + , scalingParametersStatus + , spsOptions + , spsStatus + + -- * AnalysisSchemeStatus + , AnalysisSchemeStatus + , analysisSchemeStatus + , assOptions + , assStatus + + -- * ServiceEndpoint + , ServiceEndpoint + , serviceEndpoint + , seEndpoint + + -- * Limits + , Limits + , limits + , lMaximumPartitionCount + , lMaximumReplicationCount + + -- * ExpressionStatus + , ExpressionStatus + , expressionStatus + , esOptions + , esStatus + + -- * IndexFieldType + , IndexFieldType (..) + + -- * LatLonOptions + , LatLonOptions + , latLonOptions + , lloDefaultValue + , lloFacetEnabled + , lloReturnEnabled + , lloSearchEnabled + , lloSortEnabled + , lloSourceField + + -- * SuggesterStatus + , SuggesterStatus + , suggesterStatus + , ssOptions + , ssStatus + + -- * OptionStatus + , OptionStatus + , optionStatus + , osCreationDate + , osPendingDeletion + , osState + , osUpdateDate + , osUpdateVersion + + -- * LiteralArrayOptions + , LiteralArrayOptions + , literalArrayOptions + , laoDefaultValue + , laoFacetEnabled + , laoReturnEnabled + , laoSearchEnabled + , laoSourceFields + + -- * IntArrayOptions + , IntArrayOptions + , intArrayOptions + , iaoDefaultValue + , iaoFacetEnabled + , iaoReturnEnabled + , iaoSearchEnabled + , iaoSourceFields + + -- * Expression + , Expression + , expression + , eExpressionName + , eExpressionValue + + -- * SuggesterFuzzyMatching + , SuggesterFuzzyMatching (..) + + -- * DateArrayOptions + , DateArrayOptions + , dateArrayOptions + , dao1DefaultValue + , dao1FacetEnabled + , dao1ReturnEnabled + , dao1SearchEnabled + , dao1SourceFields + + -- * AnalysisSchemeLanguage + , AnalysisSchemeLanguage (..) + + -- * PartitionInstanceType + , PartitionInstanceType (..) + + -- * Suggester + , Suggester + , suggester + , sDocumentSuggesterOptions + , sSuggesterName + + -- * IntOptions + , IntOptions + , intOptions + , ioDefaultValue + , ioFacetEnabled + , ioReturnEnabled + , ioSearchEnabled + , ioSortEnabled + , ioSourceField + + -- * LiteralOptions + , LiteralOptions + , literalOptions + , loDefaultValue + , loFacetEnabled + , loReturnEnabled + , loSearchEnabled + , loSortEnabled + , loSourceField + + -- * AccessPoliciesStatus + , AccessPoliciesStatus + , accessPoliciesStatus + , apsOptions + , apsStatus + ) where + +import Network.AWS.Error +import Network.AWS.Prelude +import Network.AWS.Signing.V4 +import qualified GHC.Exts + +-- | Version @2013-01-01@ of the Amazon CloudSearch service. +data CloudSearch + +instance AWSService CloudSearch where + type Sg CloudSearch = V4 + type Er CloudSearch = RESTError + + service = Service + { _svcEndpoint = regional + , _svcAbbrev = "CloudSearch" + , _svcPrefix = "cloudsearch" + , _svcVersion = "2013-01-01" + , _svcTargetPrefix = Nothing + , _svcJSONVersion = Nothing + } + + handle = restError statusSuccess + +ns :: Text +ns = "http://cloudsearch.amazonaws.com/doc/2013-01-01/" + +data DomainStatus = DomainStatus + { _dsARN :: Maybe Text + , _dsCreated :: Maybe Bool + , _dsDeleted :: Maybe Bool + , _dsDocService :: Maybe ServiceEndpoint + , _dsDomainId :: Text + , _dsDomainName :: Text + , _dsLimits :: Maybe Limits + , _dsProcessing :: Maybe Bool + , _dsRequiresIndexDocuments :: Bool + , _dsSearchInstanceCount :: Maybe Nat + , _dsSearchInstanceType :: Maybe Text + , _dsSearchPartitionCount :: Maybe Nat + , _dsSearchService :: Maybe ServiceEndpoint + } deriving (Eq, Show) + +-- | 'DomainStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsARN' @::@ 'Maybe' 'Text' +-- +-- * 'dsCreated' @::@ 'Maybe' 'Bool' +-- +-- * 'dsDeleted' @::@ 'Maybe' 'Bool' +-- +-- * 'dsDocService' @::@ 'Maybe' 'ServiceEndpoint' +-- +-- * 'dsDomainId' @::@ 'Text' +-- +-- * 'dsDomainName' @::@ 'Text' +-- +-- * 'dsLimits' @::@ 'Maybe' 'Limits' +-- +-- * 'dsProcessing' @::@ 'Maybe' 'Bool' +-- +-- * 'dsRequiresIndexDocuments' @::@ 'Bool' +-- +-- * 'dsSearchInstanceCount' @::@ 'Maybe' 'Natural' +-- +-- * 'dsSearchInstanceType' @::@ 'Maybe' 'Text' +-- +-- * 'dsSearchPartitionCount' @::@ 'Maybe' 'Natural' +-- +-- * 'dsSearchService' @::@ 'Maybe' 'ServiceEndpoint' +-- +domainStatus :: Text -- ^ 'dsDomainId' + -> Text -- ^ 'dsDomainName' + -> Bool -- ^ 'dsRequiresIndexDocuments' + -> DomainStatus +domainStatus p1 p2 p3 = DomainStatus + { _dsDomainId = p1 + , _dsDomainName = p2 + , _dsRequiresIndexDocuments = p3 + , _dsARN = Nothing + , _dsCreated = Nothing + , _dsDeleted = Nothing + , _dsDocService = Nothing + , _dsSearchService = Nothing + , _dsProcessing = Nothing + , _dsSearchInstanceType = Nothing + , _dsSearchPartitionCount = Nothing + , _dsSearchInstanceCount = Nothing + , _dsLimits = Nothing + } + +dsARN :: Lens' DomainStatus (Maybe Text) +dsARN = lens _dsARN (\s a -> s { _dsARN = a }) + +-- | True if the search domain is created. It can take several minutes to +-- initialize a domain when CreateDomain is called. Newly created search +-- domains are returned from DescribeDomains with a false value for Created +-- until domain creation is complete. +dsCreated :: Lens' DomainStatus (Maybe Bool) +dsCreated = lens _dsCreated (\s a -> s { _dsCreated = a }) + +-- | True if the search domain has been deleted. The system must clean up +-- resources dedicated to the search domain when DeleteDomain is called. +-- Newly deleted search domains are returned from DescribeDomains with a +-- true value for IsDeleted for several minutes until resource cleanup is +-- complete. +dsDeleted :: Lens' DomainStatus (Maybe Bool) +dsDeleted = lens _dsDeleted (\s a -> s { _dsDeleted = a }) + +-- | The service endpoint for updating documents in a search domain. +dsDocService :: Lens' DomainStatus (Maybe ServiceEndpoint) +dsDocService = lens _dsDocService (\s a -> s { _dsDocService = a }) + +dsDomainId :: Lens' DomainStatus Text +dsDomainId = lens _dsDomainId (\s a -> s { _dsDomainId = a }) + +dsDomainName :: Lens' DomainStatus Text +dsDomainName = lens _dsDomainName (\s a -> s { _dsDomainName = a }) + +dsLimits :: Lens' DomainStatus (Maybe Limits) +dsLimits = lens _dsLimits (\s a -> s { _dsLimits = a }) + +-- | True if processing is being done to activate the current domain +-- configuration. +dsProcessing :: Lens' DomainStatus (Maybe Bool) +dsProcessing = lens _dsProcessing (\s a -> s { _dsProcessing = a }) + +-- | True if IndexDocuments needs to be called to activate the current domain +-- configuration. +dsRequiresIndexDocuments :: Lens' DomainStatus Bool +dsRequiresIndexDocuments = + lens _dsRequiresIndexDocuments + (\s a -> s { _dsRequiresIndexDocuments = a }) + +-- | The number of search instances that are available to process search +-- requests. +dsSearchInstanceCount :: Lens' DomainStatus (Maybe Natural) +dsSearchInstanceCount = + lens _dsSearchInstanceCount (\s a -> s { _dsSearchInstanceCount = a }) + . mapping _Nat + +-- | The instance type that is being used to process search requests. +dsSearchInstanceType :: Lens' DomainStatus (Maybe Text) +dsSearchInstanceType = + lens _dsSearchInstanceType (\s a -> s { _dsSearchInstanceType = a }) + +-- | The number of partitions across which the search index is spread. +dsSearchPartitionCount :: Lens' DomainStatus (Maybe Natural) +dsSearchPartitionCount = + lens _dsSearchPartitionCount (\s a -> s { _dsSearchPartitionCount = a }) + . mapping _Nat + +-- | The service endpoint for requesting search results from a search domain. +dsSearchService :: Lens' DomainStatus (Maybe ServiceEndpoint) +dsSearchService = lens _dsSearchService (\s a -> s { _dsSearchService = a }) + +instance FromXML DomainStatus where + parseXML x = DomainStatus + <$> x .@? "ARN" + <*> x .@? "Created" + <*> x .@? "Deleted" + <*> x .@? "DocService" + <*> x .@ "DomainId" + <*> x .@ "DomainName" + <*> x .@? "Limits" + <*> x .@? "Processing" + <*> x .@ "RequiresIndexDocuments" + <*> x .@? "SearchInstanceCount" + <*> x .@? "SearchInstanceType" + <*> x .@? "SearchPartitionCount" + <*> x .@? "SearchService" + +instance ToQuery DomainStatus where + toQuery DomainStatus{..} = mconcat + [ "ARN" =? _dsARN + , "Created" =? _dsCreated + , "Deleted" =? _dsDeleted + , "DocService" =? _dsDocService + , "DomainId" =? _dsDomainId + , "DomainName" =? _dsDomainName + , "Limits" =? _dsLimits + , "Processing" =? _dsProcessing + , "RequiresIndexDocuments" =? _dsRequiresIndexDocuments + , "SearchInstanceCount" =? _dsSearchInstanceCount + , "SearchInstanceType" =? _dsSearchInstanceType + , "SearchPartitionCount" =? _dsSearchPartitionCount + , "SearchService" =? _dsSearchService + ] + +data DocumentSuggesterOptions = DocumentSuggesterOptions + { _dsoFuzzyMatching :: Maybe Text + , _dsoSortExpression :: Maybe Text + , _dsoSourceField :: Text + } deriving (Eq, Ord, Show) + +-- | 'DocumentSuggesterOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dsoFuzzyMatching' @::@ 'Maybe' 'Text' +-- +-- * 'dsoSortExpression' @::@ 'Maybe' 'Text' +-- +-- * 'dsoSourceField' @::@ 'Text' +-- +documentSuggesterOptions :: Text -- ^ 'dsoSourceField' + -> DocumentSuggesterOptions +documentSuggesterOptions p1 = DocumentSuggesterOptions + { _dsoSourceField = p1 + , _dsoFuzzyMatching = Nothing + , _dsoSortExpression = Nothing + } + +-- | The level of fuzziness allowed when suggesting matches for a string: +-- none, low, or high. With none, the specified string is treated as an +-- exact prefix. With low, suggestions must differ from the specified string +-- by no more than one character. With high, suggestions can differ by up to +-- two characters. The default is none. +dsoFuzzyMatching :: Lens' DocumentSuggesterOptions (Maybe Text) +dsoFuzzyMatching = lens _dsoFuzzyMatching (\s a -> s { _dsoFuzzyMatching = a }) + +-- | An expression that computes a score for each suggestion to control how +-- they are sorted. The scores are rounded to the nearest integer, with a +-- floor of 0 and a ceiling of 2^31-1. A document's relevance score is not +-- computed for suggestions, so sort expressions cannot reference the _score +-- value. To sort suggestions using a numeric field or existing expression, +-- simply specify the name of the field or expression. If no expression is +-- configured for the suggester, the suggestions are sorted with the closest +-- matches listed first. +dsoSortExpression :: Lens' DocumentSuggesterOptions (Maybe Text) +dsoSortExpression = + lens _dsoSortExpression (\s a -> s { _dsoSortExpression = a }) + +-- | The name of the index field you want to use for suggestions. +dsoSourceField :: Lens' DocumentSuggesterOptions Text +dsoSourceField = lens _dsoSourceField (\s a -> s { _dsoSourceField = a }) + +instance FromXML DocumentSuggesterOptions where + parseXML x = DocumentSuggesterOptions + <$> x .@? "FuzzyMatching" + <*> x .@? "SortExpression" + <*> x .@ "SourceField" + +instance ToQuery DocumentSuggesterOptions where + toQuery DocumentSuggesterOptions{..} = mconcat + [ "FuzzyMatching" =? _dsoFuzzyMatching + , "SortExpression" =? _dsoSortExpression + , "SourceField" =? _dsoSourceField + ] + +data DoubleArrayOptions = DoubleArrayOptions + { _daoDefaultValue :: Maybe Double + , _daoFacetEnabled :: Maybe Bool + , _daoReturnEnabled :: Maybe Bool + , _daoSearchEnabled :: Maybe Bool + , _daoSourceFields :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'DoubleArrayOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'daoDefaultValue' @::@ 'Maybe' 'Double' +-- +-- * 'daoFacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'daoReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'daoSearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'daoSourceFields' @::@ 'Maybe' 'Text' +-- +doubleArrayOptions :: DoubleArrayOptions +doubleArrayOptions = DoubleArrayOptions + { _daoDefaultValue = Nothing + , _daoSourceFields = Nothing + , _daoFacetEnabled = Nothing + , _daoSearchEnabled = Nothing + , _daoReturnEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +daoDefaultValue :: Lens' DoubleArrayOptions (Maybe Double) +daoDefaultValue = lens _daoDefaultValue (\s a -> s { _daoDefaultValue = a }) + +-- | Whether facet information can be returned for the field. +daoFacetEnabled :: Lens' DoubleArrayOptions (Maybe Bool) +daoFacetEnabled = lens _daoFacetEnabled (\s a -> s { _daoFacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +daoReturnEnabled :: Lens' DoubleArrayOptions (Maybe Bool) +daoReturnEnabled = lens _daoReturnEnabled (\s a -> s { _daoReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +daoSearchEnabled :: Lens' DoubleArrayOptions (Maybe Bool) +daoSearchEnabled = lens _daoSearchEnabled (\s a -> s { _daoSearchEnabled = a }) + +-- | A list of source fields to map to the field. +daoSourceFields :: Lens' DoubleArrayOptions (Maybe Text) +daoSourceFields = lens _daoSourceFields (\s a -> s { _daoSourceFields = a }) + +instance FromXML DoubleArrayOptions where + parseXML x = DoubleArrayOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SourceFields" + +instance ToQuery DoubleArrayOptions where + toQuery DoubleArrayOptions{..} = mconcat + [ "DefaultValue" =? _daoDefaultValue + , "FacetEnabled" =? _daoFacetEnabled + , "ReturnEnabled" =? _daoReturnEnabled + , "SearchEnabled" =? _daoSearchEnabled + , "SourceFields" =? _daoSourceFields + ] + +data IndexField = IndexField + { _ifDateArrayOptions :: Maybe DateArrayOptions + , _ifDateOptions :: Maybe DateOptions + , _ifDoubleArrayOptions :: Maybe DoubleArrayOptions + , _ifDoubleOptions :: Maybe DoubleOptions + , _ifIndexFieldName :: Text + , _ifIndexFieldType :: Text + , _ifIntArrayOptions :: Maybe IntArrayOptions + , _ifIntOptions :: Maybe IntOptions + , _ifLatLonOptions :: Maybe LatLonOptions + , _ifLiteralArrayOptions :: Maybe LiteralArrayOptions + , _ifLiteralOptions :: Maybe LiteralOptions + , _ifTextArrayOptions :: Maybe TextArrayOptions + , _ifTextOptions :: Maybe TextOptions + } deriving (Eq, Show) + +-- | 'IndexField' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ifDateArrayOptions' @::@ 'Maybe' 'DateArrayOptions' +-- +-- * 'ifDateOptions' @::@ 'Maybe' 'DateOptions' +-- +-- * 'ifDoubleArrayOptions' @::@ 'Maybe' 'DoubleArrayOptions' +-- +-- * 'ifDoubleOptions' @::@ 'Maybe' 'DoubleOptions' +-- +-- * 'ifIndexFieldName' @::@ 'Text' +-- +-- * 'ifIndexFieldType' @::@ 'Text' +-- +-- * 'ifIntArrayOptions' @::@ 'Maybe' 'IntArrayOptions' +-- +-- * 'ifIntOptions' @::@ 'Maybe' 'IntOptions' +-- +-- * 'ifLatLonOptions' @::@ 'Maybe' 'LatLonOptions' +-- +-- * 'ifLiteralArrayOptions' @::@ 'Maybe' 'LiteralArrayOptions' +-- +-- * 'ifLiteralOptions' @::@ 'Maybe' 'LiteralOptions' +-- +-- * 'ifTextArrayOptions' @::@ 'Maybe' 'TextArrayOptions' +-- +-- * 'ifTextOptions' @::@ 'Maybe' 'TextOptions' +-- +indexField :: Text -- ^ 'ifIndexFieldName' + -> Text -- ^ 'ifIndexFieldType' + -> IndexField +indexField p1 p2 = IndexField + { _ifIndexFieldName = p1 + , _ifIndexFieldType = p2 + , _ifIntOptions = Nothing + , _ifDoubleOptions = Nothing + , _ifLiteralOptions = Nothing + , _ifTextOptions = Nothing + , _ifDateOptions = Nothing + , _ifLatLonOptions = Nothing + , _ifIntArrayOptions = Nothing + , _ifDoubleArrayOptions = Nothing + , _ifLiteralArrayOptions = Nothing + , _ifTextArrayOptions = Nothing + , _ifDateArrayOptions = Nothing + } + +ifDateArrayOptions :: Lens' IndexField (Maybe DateArrayOptions) +ifDateArrayOptions = + lens _ifDateArrayOptions (\s a -> s { _ifDateArrayOptions = a }) + +ifDateOptions :: Lens' IndexField (Maybe DateOptions) +ifDateOptions = lens _ifDateOptions (\s a -> s { _ifDateOptions = a }) + +ifDoubleArrayOptions :: Lens' IndexField (Maybe DoubleArrayOptions) +ifDoubleArrayOptions = + lens _ifDoubleArrayOptions (\s a -> s { _ifDoubleArrayOptions = a }) + +ifDoubleOptions :: Lens' IndexField (Maybe DoubleOptions) +ifDoubleOptions = lens _ifDoubleOptions (\s a -> s { _ifDoubleOptions = a }) + +-- | The name of a field in the search index. Field names must begin with a +-- letter and can contain the following characters: a-z (lowercase), 0-9, +-- and _ (underscore). Uppercase letters and hyphens are not allowed. The +-- name "score" is reserved and cannot be specified as field or expression +-- name. +ifIndexFieldName :: Lens' IndexField Text +ifIndexFieldName = lens _ifIndexFieldName (\s a -> s { _ifIndexFieldName = a }) + +ifIndexFieldType :: Lens' IndexField Text +ifIndexFieldType = lens _ifIndexFieldType (\s a -> s { _ifIndexFieldType = a }) + +ifIntArrayOptions :: Lens' IndexField (Maybe IntArrayOptions) +ifIntArrayOptions = + lens _ifIntArrayOptions (\s a -> s { _ifIntArrayOptions = a }) + +ifIntOptions :: Lens' IndexField (Maybe IntOptions) +ifIntOptions = lens _ifIntOptions (\s a -> s { _ifIntOptions = a }) + +ifLatLonOptions :: Lens' IndexField (Maybe LatLonOptions) +ifLatLonOptions = lens _ifLatLonOptions (\s a -> s { _ifLatLonOptions = a }) + +ifLiteralArrayOptions :: Lens' IndexField (Maybe LiteralArrayOptions) +ifLiteralArrayOptions = + lens _ifLiteralArrayOptions (\s a -> s { _ifLiteralArrayOptions = a }) + +ifLiteralOptions :: Lens' IndexField (Maybe LiteralOptions) +ifLiteralOptions = lens _ifLiteralOptions (\s a -> s { _ifLiteralOptions = a }) + +ifTextArrayOptions :: Lens' IndexField (Maybe TextArrayOptions) +ifTextArrayOptions = + lens _ifTextArrayOptions (\s a -> s { _ifTextArrayOptions = a }) + +ifTextOptions :: Lens' IndexField (Maybe TextOptions) +ifTextOptions = lens _ifTextOptions (\s a -> s { _ifTextOptions = a }) + +instance FromXML IndexField where + parseXML x = IndexField + <$> x .@? "DateArrayOptions" + <*> x .@? "DateOptions" + <*> x .@? "DoubleArrayOptions" + <*> x .@? "DoubleOptions" + <*> x .@ "IndexFieldName" + <*> x .@ "IndexFieldType" + <*> x .@? "IntArrayOptions" + <*> x .@? "IntOptions" + <*> x .@? "LatLonOptions" + <*> x .@? "LiteralArrayOptions" + <*> x .@? "LiteralOptions" + <*> x .@? "TextArrayOptions" + <*> x .@? "TextOptions" + +instance ToQuery IndexField where + toQuery IndexField{..} = mconcat + [ "DateArrayOptions" =? _ifDateArrayOptions + , "DateOptions" =? _ifDateOptions + , "DoubleArrayOptions" =? _ifDoubleArrayOptions + , "DoubleOptions" =? _ifDoubleOptions + , "IndexFieldName" =? _ifIndexFieldName + , "IndexFieldType" =? _ifIndexFieldType + , "IntArrayOptions" =? _ifIntArrayOptions + , "IntOptions" =? _ifIntOptions + , "LatLonOptions" =? _ifLatLonOptions + , "LiteralArrayOptions" =? _ifLiteralArrayOptions + , "LiteralOptions" =? _ifLiteralOptions + , "TextArrayOptions" =? _ifTextArrayOptions + , "TextOptions" =? _ifTextOptions + ] + +data DateOptions = DateOptions + { _doDefaultValue :: Maybe Text + , _doFacetEnabled :: Maybe Bool + , _doReturnEnabled :: Maybe Bool + , _doSearchEnabled :: Maybe Bool + , _doSortEnabled :: Maybe Bool + , _doSourceField :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'DateOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'doDefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'doFacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'doReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'doSearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'doSortEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'doSourceField' @::@ 'Maybe' 'Text' +-- +dateOptions :: DateOptions +dateOptions = DateOptions + { _doDefaultValue = Nothing + , _doSourceField = Nothing + , _doFacetEnabled = Nothing + , _doSearchEnabled = Nothing + , _doReturnEnabled = Nothing + , _doSortEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +doDefaultValue :: Lens' DateOptions (Maybe Text) +doDefaultValue = lens _doDefaultValue (\s a -> s { _doDefaultValue = a }) + +-- | Whether facet information can be returned for the field. +doFacetEnabled :: Lens' DateOptions (Maybe Bool) +doFacetEnabled = lens _doFacetEnabled (\s a -> s { _doFacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +doReturnEnabled :: Lens' DateOptions (Maybe Bool) +doReturnEnabled = lens _doReturnEnabled (\s a -> s { _doReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +doSearchEnabled :: Lens' DateOptions (Maybe Bool) +doSearchEnabled = lens _doSearchEnabled (\s a -> s { _doSearchEnabled = a }) + +-- | Whether the field can be used to sort the search results. +doSortEnabled :: Lens' DateOptions (Maybe Bool) +doSortEnabled = lens _doSortEnabled (\s a -> s { _doSortEnabled = a }) + +doSourceField :: Lens' DateOptions (Maybe Text) +doSourceField = lens _doSourceField (\s a -> s { _doSourceField = a }) + +instance FromXML DateOptions where + parseXML x = DateOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SortEnabled" + <*> x .@? "SourceField" + +instance ToQuery DateOptions where + toQuery DateOptions{..} = mconcat + [ "DefaultValue" =? _doDefaultValue + , "FacetEnabled" =? _doFacetEnabled + , "ReturnEnabled" =? _doReturnEnabled + , "SearchEnabled" =? _doSearchEnabled + , "SortEnabled" =? _doSortEnabled + , "SourceField" =? _doSourceField + ] + +data OptionState + = Active -- ^ Active + | FailedToValidate -- ^ FailedToValidate + | Processing -- ^ Processing + | RequiresIndexDocuments -- ^ RequiresIndexDocuments + deriving (Eq, Ord, Show, Generic, Enum) + +instance Hashable OptionState + +instance FromText OptionState where + parser = match "Active" Active + <|> match "FailedToValidate" FailedToValidate + <|> match "Processing" Processing + <|> match "RequiresIndexDocuments" RequiresIndexDocuments + +instance ToText OptionState where + toText = \case + Active -> "Active" + FailedToValidate -> "FailedToValidate" + Processing -> "Processing" + RequiresIndexDocuments -> "RequiresIndexDocuments" + +instance FromXML OptionState where + parseXML = parseXMLText "OptionState" + +instance ToQuery OptionState where + toQuery = toQuery . toText + +data TextArrayOptions = TextArrayOptions + { _taoAnalysisScheme :: Maybe Text + , _taoDefaultValue :: Maybe Text + , _taoHighlightEnabled :: Maybe Bool + , _taoReturnEnabled :: Maybe Bool + , _taoSourceFields :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'TextArrayOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'taoAnalysisScheme' @::@ 'Maybe' 'Text' +-- +-- * 'taoDefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'taoHighlightEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'taoReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'taoSourceFields' @::@ 'Maybe' 'Text' +-- +textArrayOptions :: TextArrayOptions +textArrayOptions = TextArrayOptions + { _taoDefaultValue = Nothing + , _taoSourceFields = Nothing + , _taoReturnEnabled = Nothing + , _taoHighlightEnabled = Nothing + , _taoAnalysisScheme = Nothing + } + +-- | The name of an analysis scheme for a text-array field. +taoAnalysisScheme :: Lens' TextArrayOptions (Maybe Text) +taoAnalysisScheme = + lens _taoAnalysisScheme (\s a -> s { _taoAnalysisScheme = a }) + +-- | A value to use for the field if the field isn't specified for a document. +taoDefaultValue :: Lens' TextArrayOptions (Maybe Text) +taoDefaultValue = lens _taoDefaultValue (\s a -> s { _taoDefaultValue = a }) + +-- | Whether highlights can be returned for the field. +taoHighlightEnabled :: Lens' TextArrayOptions (Maybe Bool) +taoHighlightEnabled = + lens _taoHighlightEnabled (\s a -> s { _taoHighlightEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +taoReturnEnabled :: Lens' TextArrayOptions (Maybe Bool) +taoReturnEnabled = lens _taoReturnEnabled (\s a -> s { _taoReturnEnabled = a }) + +-- | A list of source fields to map to the field. +taoSourceFields :: Lens' TextArrayOptions (Maybe Text) +taoSourceFields = lens _taoSourceFields (\s a -> s { _taoSourceFields = a }) + +instance FromXML TextArrayOptions where + parseXML x = TextArrayOptions + <$> x .@? "AnalysisScheme" + <*> x .@? "DefaultValue" + <*> x .@? "HighlightEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SourceFields" + +instance ToQuery TextArrayOptions where + toQuery TextArrayOptions{..} = mconcat + [ "AnalysisScheme" =? _taoAnalysisScheme + , "DefaultValue" =? _taoDefaultValue + , "HighlightEnabled" =? _taoHighlightEnabled + , "ReturnEnabled" =? _taoReturnEnabled + , "SourceFields" =? _taoSourceFields + ] + +data AlgorithmicStemming + = Full -- ^ full + | Light -- ^ light + | Minimal -- ^ minimal + | None -- ^ none + deriving (Eq, Ord, Show, Generic, Enum) + +instance Hashable AlgorithmicStemming + +instance FromText AlgorithmicStemming where + parser = match "full" Full + <|> match "light" Light + <|> match "minimal" Minimal + <|> match "none" None + +instance ToText AlgorithmicStemming where + toText = \case + Full -> "full" + Light -> "light" + Minimal -> "minimal" + None -> "none" + +instance FromXML AlgorithmicStemming where + parseXML = parseXMLText "AlgorithmicStemming" + +instance ToQuery AlgorithmicStemming where + toQuery = toQuery . toText + +data AnalysisScheme = AnalysisScheme + { _asAnalysisOptions :: Maybe AnalysisOptions + , _asAnalysisSchemeLanguage :: Text + , _asAnalysisSchemeName :: Text + } deriving (Eq, Show) + +-- | 'AnalysisScheme' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'asAnalysisOptions' @::@ 'Maybe' 'AnalysisOptions' +-- +-- * 'asAnalysisSchemeLanguage' @::@ 'Text' +-- +-- * 'asAnalysisSchemeName' @::@ 'Text' +-- +analysisScheme :: Text -- ^ 'asAnalysisSchemeName' + -> Text -- ^ 'asAnalysisSchemeLanguage' + -> AnalysisScheme +analysisScheme p1 p2 = AnalysisScheme + { _asAnalysisSchemeName = p1 + , _asAnalysisSchemeLanguage = p2 + , _asAnalysisOptions = Nothing + } + +asAnalysisOptions :: Lens' AnalysisScheme (Maybe AnalysisOptions) +asAnalysisOptions = + lens _asAnalysisOptions (\s a -> s { _asAnalysisOptions = a }) + +asAnalysisSchemeLanguage :: Lens' AnalysisScheme Text +asAnalysisSchemeLanguage = + lens _asAnalysisSchemeLanguage + (\s a -> s { _asAnalysisSchemeLanguage = a }) + +asAnalysisSchemeName :: Lens' AnalysisScheme Text +asAnalysisSchemeName = + lens _asAnalysisSchemeName (\s a -> s { _asAnalysisSchemeName = a }) + +instance FromXML AnalysisScheme where + parseXML x = AnalysisScheme + <$> x .@? "AnalysisOptions" + <*> x .@ "AnalysisSchemeLanguage" + <*> x .@ "AnalysisSchemeName" + +instance ToQuery AnalysisScheme where + toQuery AnalysisScheme{..} = mconcat + [ "AnalysisOptions" =? _asAnalysisOptions + , "AnalysisSchemeLanguage" =? _asAnalysisSchemeLanguage + , "AnalysisSchemeName" =? _asAnalysisSchemeName + ] + +data ScalingParameters = ScalingParameters + { _spDesiredInstanceType :: Maybe Text + , _spDesiredPartitionCount :: Maybe Nat + , _spDesiredReplicationCount :: Maybe Nat + } deriving (Eq, Ord, Show) + +-- | 'ScalingParameters' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'spDesiredInstanceType' @::@ 'Maybe' 'Text' +-- +-- * 'spDesiredPartitionCount' @::@ 'Maybe' 'Natural' +-- +-- * 'spDesiredReplicationCount' @::@ 'Maybe' 'Natural' +-- +scalingParameters :: ScalingParameters +scalingParameters = ScalingParameters + { _spDesiredInstanceType = Nothing + , _spDesiredReplicationCount = Nothing + , _spDesiredPartitionCount = Nothing + } + +-- | The instance type that you want to preconfigure for your domain. For +-- example, search.m1.small. +spDesiredInstanceType :: Lens' ScalingParameters (Maybe Text) +spDesiredInstanceType = + lens _spDesiredInstanceType (\s a -> s { _spDesiredInstanceType = a }) + +-- | The number of partitions you want to preconfigure for your domain. Only +-- valid when you select m2.2xlarge as the desired instance type. +spDesiredPartitionCount :: Lens' ScalingParameters (Maybe Natural) +spDesiredPartitionCount = + lens _spDesiredPartitionCount (\s a -> s { _spDesiredPartitionCount = a }) + . mapping _Nat + +-- | The number of replicas you want to preconfigure for each index partition. +spDesiredReplicationCount :: Lens' ScalingParameters (Maybe Natural) +spDesiredReplicationCount = + lens _spDesiredReplicationCount + (\s a -> s { _spDesiredReplicationCount = a }) + . mapping _Nat + +instance FromXML ScalingParameters where + parseXML x = ScalingParameters + <$> x .@? "DesiredInstanceType" + <*> x .@? "DesiredPartitionCount" + <*> x .@? "DesiredReplicationCount" + +instance ToQuery ScalingParameters where + toQuery ScalingParameters{..} = mconcat + [ "DesiredInstanceType" =? _spDesiredInstanceType + , "DesiredPartitionCount" =? _spDesiredPartitionCount + , "DesiredReplicationCount" =? _spDesiredReplicationCount + ] + +data AnalysisOptions = AnalysisOptions + { _aoAlgorithmicStemming :: Maybe Text + , _aoJapaneseTokenizationDictionary :: Maybe Text + , _aoStemmingDictionary :: Maybe Text + , _aoStopwords :: Maybe Text + , _aoSynonyms :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'AnalysisOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'aoAlgorithmicStemming' @::@ 'Maybe' 'Text' +-- +-- * 'aoJapaneseTokenizationDictionary' @::@ 'Maybe' 'Text' +-- +-- * 'aoStemmingDictionary' @::@ 'Maybe' 'Text' +-- +-- * 'aoStopwords' @::@ 'Maybe' 'Text' +-- +-- * 'aoSynonyms' @::@ 'Maybe' 'Text' +-- +analysisOptions :: AnalysisOptions +analysisOptions = AnalysisOptions + { _aoSynonyms = Nothing + , _aoStopwords = Nothing + , _aoStemmingDictionary = Nothing + , _aoJapaneseTokenizationDictionary = Nothing + , _aoAlgorithmicStemming = Nothing + } + +-- | The level of algorithmic stemming to perform: none, minimal, light, or +-- full. The available levels vary depending on the language. For more +-- information, see Language Specific Text Processing Settings in the Amazon +-- CloudSearch Developer Guide. +aoAlgorithmicStemming :: Lens' AnalysisOptions (Maybe Text) +aoAlgorithmicStemming = + lens _aoAlgorithmicStemming (\s a -> s { _aoAlgorithmicStemming = a }) + +-- | A JSON array that contains a collection of terms, tokens, readings and +-- part of speech for Japanese Tokenizaiton. The Japanese tokenization +-- dictionary enables you to override the default tokenization for selected +-- terms. This is only valid for Japanese language fields. +aoJapaneseTokenizationDictionary :: Lens' AnalysisOptions (Maybe Text) +aoJapaneseTokenizationDictionary = + lens _aoJapaneseTokenizationDictionary + (\s a -> s { _aoJapaneseTokenizationDictionary = a }) + +-- | A JSON object that contains a collection of string:value pairs that each +-- map a term to its stem. For example, {"term1": "stem1", "term2": "stem2", +-- "term3": "stem3"}. The stemming dictionary is applied in addition to any +-- algorithmic stemming. This enables you to override the results of the +-- algorithmic stemming to correct specific cases of overstemming or +-- understemming. The maximum size of a stemming dictionary is 500 KB. +aoStemmingDictionary :: Lens' AnalysisOptions (Maybe Text) +aoStemmingDictionary = + lens _aoStemmingDictionary (\s a -> s { _aoStemmingDictionary = a }) + +-- | A JSON array of terms to ignore during indexing and searching. For +-- example, ["a", "an", "the", "of"]. The stopwords dictionary must +-- explicitly list each word you want to ignore. Wildcards and regular +-- expressions are not supported. +aoStopwords :: Lens' AnalysisOptions (Maybe Text) +aoStopwords = lens _aoStopwords (\s a -> s { _aoStopwords = a }) + +-- | A JSON object that defines synonym groups and aliases. A synonym group is +-- an array of arrays, where each sub-array is a group of terms where each +-- term in the group is considered a synonym of every other term in the +-- group. The aliases value is an object that contains a collection of +-- string:value pairs where the string specifies a term and the array of +-- values specifies each of the aliases for that term. An alias is +-- considered a synonym of the specified term, but the term is not +-- considered a synonym of the alias. For more information about specifying +-- synonyms, see Synonyms in the Amazon CloudSearch Developer Guide. +aoSynonyms :: Lens' AnalysisOptions (Maybe Text) +aoSynonyms = lens _aoSynonyms (\s a -> s { _aoSynonyms = a }) + +instance FromXML AnalysisOptions where + parseXML x = AnalysisOptions + <$> x .@? "AlgorithmicStemming" + <*> x .@? "JapaneseTokenizationDictionary" + <*> x .@? "StemmingDictionary" + <*> x .@? "Stopwords" + <*> x .@? "Synonyms" + +instance ToQuery AnalysisOptions where + toQuery AnalysisOptions{..} = mconcat + [ "AlgorithmicStemming" =? _aoAlgorithmicStemming + , "JapaneseTokenizationDictionary" =? _aoJapaneseTokenizationDictionary + , "StemmingDictionary" =? _aoStemmingDictionary + , "Stopwords" =? _aoStopwords + , "Synonyms" =? _aoSynonyms + ] + +data DoubleOptions = DoubleOptions + { _do1DefaultValue :: Maybe Double + , _do1FacetEnabled :: Maybe Bool + , _do1ReturnEnabled :: Maybe Bool + , _do1SearchEnabled :: Maybe Bool + , _do1SortEnabled :: Maybe Bool + , _do1SourceField :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'DoubleOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'do1DefaultValue' @::@ 'Maybe' 'Double' +-- +-- * 'do1FacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'do1ReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'do1SearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'do1SortEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'do1SourceField' @::@ 'Maybe' 'Text' +-- +doubleOptions :: DoubleOptions +doubleOptions = DoubleOptions + { _do1DefaultValue = Nothing + , _do1SourceField = Nothing + , _do1FacetEnabled = Nothing + , _do1SearchEnabled = Nothing + , _do1ReturnEnabled = Nothing + , _do1SortEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +-- This can be important if you are using the field in an expression and +-- that field is not present in every document. +do1DefaultValue :: Lens' DoubleOptions (Maybe Double) +do1DefaultValue = lens _do1DefaultValue (\s a -> s { _do1DefaultValue = a }) + +-- | Whether facet information can be returned for the field. +do1FacetEnabled :: Lens' DoubleOptions (Maybe Bool) +do1FacetEnabled = lens _do1FacetEnabled (\s a -> s { _do1FacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +do1ReturnEnabled :: Lens' DoubleOptions (Maybe Bool) +do1ReturnEnabled = lens _do1ReturnEnabled (\s a -> s { _do1ReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +do1SearchEnabled :: Lens' DoubleOptions (Maybe Bool) +do1SearchEnabled = lens _do1SearchEnabled (\s a -> s { _do1SearchEnabled = a }) + +-- | Whether the field can be used to sort the search results. +do1SortEnabled :: Lens' DoubleOptions (Maybe Bool) +do1SortEnabled = lens _do1SortEnabled (\s a -> s { _do1SortEnabled = a }) + +-- | The name of the source field to map to the field. +do1SourceField :: Lens' DoubleOptions (Maybe Text) +do1SourceField = lens _do1SourceField (\s a -> s { _do1SourceField = a }) + +instance FromXML DoubleOptions where + parseXML x = DoubleOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SortEnabled" + <*> x .@? "SourceField" + +instance ToQuery DoubleOptions where + toQuery DoubleOptions{..} = mconcat + [ "DefaultValue" =? _do1DefaultValue + , "FacetEnabled" =? _do1FacetEnabled + , "ReturnEnabled" =? _do1ReturnEnabled + , "SearchEnabled" =? _do1SearchEnabled + , "SortEnabled" =? _do1SortEnabled + , "SourceField" =? _do1SourceField + ] + +data TextOptions = TextOptions + { _toAnalysisScheme :: Maybe Text + , _toDefaultValue :: Maybe Text + , _toHighlightEnabled :: Maybe Bool + , _toReturnEnabled :: Maybe Bool + , _toSortEnabled :: Maybe Bool + , _toSourceField :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'TextOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'toAnalysisScheme' @::@ 'Maybe' 'Text' +-- +-- * 'toDefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'toHighlightEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'toReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'toSortEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'toSourceField' @::@ 'Maybe' 'Text' +-- +textOptions :: TextOptions +textOptions = TextOptions + { _toDefaultValue = Nothing + , _toSourceField = Nothing + , _toReturnEnabled = Nothing + , _toSortEnabled = Nothing + , _toHighlightEnabled = Nothing + , _toAnalysisScheme = Nothing + } + +-- | The name of an analysis scheme for a text field. +toAnalysisScheme :: Lens' TextOptions (Maybe Text) +toAnalysisScheme = lens _toAnalysisScheme (\s a -> s { _toAnalysisScheme = a }) + +-- | A value to use for the field if the field isn't specified for a document. +toDefaultValue :: Lens' TextOptions (Maybe Text) +toDefaultValue = lens _toDefaultValue (\s a -> s { _toDefaultValue = a }) + +-- | Whether highlights can be returned for the field. +toHighlightEnabled :: Lens' TextOptions (Maybe Bool) +toHighlightEnabled = + lens _toHighlightEnabled (\s a -> s { _toHighlightEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +toReturnEnabled :: Lens' TextOptions (Maybe Bool) +toReturnEnabled = lens _toReturnEnabled (\s a -> s { _toReturnEnabled = a }) + +-- | Whether the field can be used to sort the search results. +toSortEnabled :: Lens' TextOptions (Maybe Bool) +toSortEnabled = lens _toSortEnabled (\s a -> s { _toSortEnabled = a }) + +toSourceField :: Lens' TextOptions (Maybe Text) +toSourceField = lens _toSourceField (\s a -> s { _toSourceField = a }) + +instance FromXML TextOptions where + parseXML x = TextOptions + <$> x .@? "AnalysisScheme" + <*> x .@? "DefaultValue" + <*> x .@? "HighlightEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SortEnabled" + <*> x .@? "SourceField" + +instance ToQuery TextOptions where + toQuery TextOptions{..} = mconcat + [ "AnalysisScheme" =? _toAnalysisScheme + , "DefaultValue" =? _toDefaultValue + , "HighlightEnabled" =? _toHighlightEnabled + , "ReturnEnabled" =? _toReturnEnabled + , "SortEnabled" =? _toSortEnabled + , "SourceField" =? _toSourceField + ] + +data AvailabilityOptionsStatus = AvailabilityOptionsStatus + { _aosOptions :: Bool + , _aosStatus :: OptionStatus + } deriving (Eq, Show) + +-- | 'AvailabilityOptionsStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'aosOptions' @::@ 'Bool' +-- +-- * 'aosStatus' @::@ 'OptionStatus' +-- +availabilityOptionsStatus :: Bool -- ^ 'aosOptions' + -> OptionStatus -- ^ 'aosStatus' + -> AvailabilityOptionsStatus +availabilityOptionsStatus p1 p2 = AvailabilityOptionsStatus + { _aosOptions = p1 + , _aosStatus = p2 + } + +-- | The availability options configured for the domain. +aosOptions :: Lens' AvailabilityOptionsStatus Bool +aosOptions = lens _aosOptions (\s a -> s { _aosOptions = a }) + +aosStatus :: Lens' AvailabilityOptionsStatus OptionStatus +aosStatus = lens _aosStatus (\s a -> s { _aosStatus = a }) + +instance FromXML AvailabilityOptionsStatus where + parseXML x = AvailabilityOptionsStatus + <$> x .@ "Options" + <*> x .@ "Status" + +instance ToQuery AvailabilityOptionsStatus where + toQuery AvailabilityOptionsStatus{..} = mconcat + [ "Options" =? _aosOptions + , "Status" =? _aosStatus + ] + +data IndexFieldStatus = IndexFieldStatus + { _ifsOptions :: IndexField + , _ifsStatus :: OptionStatus + } deriving (Eq, Show) + +-- | 'IndexFieldStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ifsOptions' @::@ 'IndexField' +-- +-- * 'ifsStatus' @::@ 'OptionStatus' +-- +indexFieldStatus :: IndexField -- ^ 'ifsOptions' + -> OptionStatus -- ^ 'ifsStatus' + -> IndexFieldStatus +indexFieldStatus p1 p2 = IndexFieldStatus + { _ifsOptions = p1 + , _ifsStatus = p2 + } + +ifsOptions :: Lens' IndexFieldStatus IndexField +ifsOptions = lens _ifsOptions (\s a -> s { _ifsOptions = a }) + +ifsStatus :: Lens' IndexFieldStatus OptionStatus +ifsStatus = lens _ifsStatus (\s a -> s { _ifsStatus = a }) + +instance FromXML IndexFieldStatus where + parseXML x = IndexFieldStatus + <$> x .@ "Options" + <*> x .@ "Status" + +instance ToQuery IndexFieldStatus where + toQuery IndexFieldStatus{..} = mconcat + [ "Options" =? _ifsOptions + , "Status" =? _ifsStatus + ] + +data ScalingParametersStatus = ScalingParametersStatus + { _spsOptions :: ScalingParameters + , _spsStatus :: OptionStatus + } deriving (Eq, Show) + +-- | 'ScalingParametersStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'spsOptions' @::@ 'ScalingParameters' +-- +-- * 'spsStatus' @::@ 'OptionStatus' +-- +scalingParametersStatus :: ScalingParameters -- ^ 'spsOptions' + -> OptionStatus -- ^ 'spsStatus' + -> ScalingParametersStatus +scalingParametersStatus p1 p2 = ScalingParametersStatus + { _spsOptions = p1 + , _spsStatus = p2 + } + +spsOptions :: Lens' ScalingParametersStatus ScalingParameters +spsOptions = lens _spsOptions (\s a -> s { _spsOptions = a }) + +spsStatus :: Lens' ScalingParametersStatus OptionStatus +spsStatus = lens _spsStatus (\s a -> s { _spsStatus = a }) + +instance FromXML ScalingParametersStatus where + parseXML x = ScalingParametersStatus + <$> x .@ "Options" + <*> x .@ "Status" + +instance ToQuery ScalingParametersStatus where + toQuery ScalingParametersStatus{..} = mconcat + [ "Options" =? _spsOptions + , "Status" =? _spsStatus + ] + +data AnalysisSchemeStatus = AnalysisSchemeStatus + { _assOptions :: AnalysisScheme + , _assStatus :: OptionStatus + } deriving (Eq, Show) + +-- | 'AnalysisSchemeStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'assOptions' @::@ 'AnalysisScheme' +-- +-- * 'assStatus' @::@ 'OptionStatus' +-- +analysisSchemeStatus :: AnalysisScheme -- ^ 'assOptions' + -> OptionStatus -- ^ 'assStatus' + -> AnalysisSchemeStatus +analysisSchemeStatus p1 p2 = AnalysisSchemeStatus + { _assOptions = p1 + , _assStatus = p2 + } + +assOptions :: Lens' AnalysisSchemeStatus AnalysisScheme +assOptions = lens _assOptions (\s a -> s { _assOptions = a }) + +assStatus :: Lens' AnalysisSchemeStatus OptionStatus +assStatus = lens _assStatus (\s a -> s { _assStatus = a }) + +instance FromXML AnalysisSchemeStatus where + parseXML x = AnalysisSchemeStatus + <$> x .@ "Options" + <*> x .@ "Status" + +instance ToQuery AnalysisSchemeStatus where + toQuery AnalysisSchemeStatus{..} = mconcat + [ "Options" =? _assOptions + , "Status" =? _assStatus + ] + +newtype ServiceEndpoint = ServiceEndpoint + { _seEndpoint :: Maybe Text + } deriving (Eq, Ord, Show, Monoid) + +-- | 'ServiceEndpoint' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'seEndpoint' @::@ 'Maybe' 'Text' +-- +serviceEndpoint :: ServiceEndpoint +serviceEndpoint = ServiceEndpoint + { _seEndpoint = Nothing + } + +seEndpoint :: Lens' ServiceEndpoint (Maybe Text) +seEndpoint = lens _seEndpoint (\s a -> s { _seEndpoint = a }) + +instance FromXML ServiceEndpoint where + parseXML x = ServiceEndpoint + <$> x .@? "Endpoint" + +instance ToQuery ServiceEndpoint where + toQuery ServiceEndpoint{..} = mconcat + [ "Endpoint" =? _seEndpoint + ] + +data Limits = Limits + { _lMaximumPartitionCount :: Nat + , _lMaximumReplicationCount :: Nat + } deriving (Eq, Ord, Show) + +-- | 'Limits' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'lMaximumPartitionCount' @::@ 'Natural' +-- +-- * 'lMaximumReplicationCount' @::@ 'Natural' +-- +limits :: Natural -- ^ 'lMaximumReplicationCount' + -> Natural -- ^ 'lMaximumPartitionCount' + -> Limits +limits p1 p2 = Limits + { _lMaximumReplicationCount = withIso _Nat (const id) p1 + , _lMaximumPartitionCount = withIso _Nat (const id) p2 + } + +lMaximumPartitionCount :: Lens' Limits Natural +lMaximumPartitionCount = + lens _lMaximumPartitionCount (\s a -> s { _lMaximumPartitionCount = a }) + . _Nat + +lMaximumReplicationCount :: Lens' Limits Natural +lMaximumReplicationCount = + lens _lMaximumReplicationCount + (\s a -> s { _lMaximumReplicationCount = a }) + . _Nat + +instance FromXML Limits where + parseXML x = Limits + <$> x .@ "MaximumPartitionCount" + <*> x .@ "MaximumReplicationCount" + +instance ToQuery Limits where + toQuery Limits{..} = mconcat + [ "MaximumPartitionCount" =? _lMaximumPartitionCount + , "MaximumReplicationCount" =? _lMaximumReplicationCount + ] + +data ExpressionStatus = ExpressionStatus + { _esOptions :: Expression + , _esStatus :: OptionStatus + } deriving (Eq, Show) + +-- | 'ExpressionStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'esOptions' @::@ 'Expression' +-- +-- * 'esStatus' @::@ 'OptionStatus' +-- +expressionStatus :: Expression -- ^ 'esOptions' + -> OptionStatus -- ^ 'esStatus' + -> ExpressionStatus +expressionStatus p1 p2 = ExpressionStatus + { _esOptions = p1 + , _esStatus = p2 + } + +-- | The expression that is evaluated for sorting while processing a search +-- request. +esOptions :: Lens' ExpressionStatus Expression +esOptions = lens _esOptions (\s a -> s { _esOptions = a }) + +esStatus :: Lens' ExpressionStatus OptionStatus +esStatus = lens _esStatus (\s a -> s { _esStatus = a }) + +instance FromXML ExpressionStatus where + parseXML x = ExpressionStatus + <$> x .@ "Options" + <*> x .@ "Status" + +instance ToQuery ExpressionStatus where + toQuery ExpressionStatus{..} = mconcat + [ "Options" =? _esOptions + , "Status" =? _esStatus + ] + +data IndexFieldType + = IFTDate -- ^ date + | IFTDateArray -- ^ date-array + | IFTDouble -- ^ double + | IFTDoubleArray -- ^ double-array + | IFTInt -- ^ int + | IFTIntArray -- ^ int-array + | IFTLatlon -- ^ latlon + | IFTLiteral -- ^ literal + | IFTLiteralArray -- ^ literal-array + | IFTText -- ^ text + | IFTTextArray -- ^ text-array + deriving (Eq, Ord, Show, Generic, Enum) + +instance Hashable IndexFieldType + +instance FromText IndexFieldType where + parser = match "date" IFTDate + <|> match "date-array" IFTDateArray + <|> match "double" IFTDouble + <|> match "double-array" IFTDoubleArray + <|> match "int" IFTInt + <|> match "int-array" IFTIntArray + <|> match "latlon" IFTLatlon + <|> match "literal" IFTLiteral + <|> match "literal-array" IFTLiteralArray + <|> match "text" IFTText + <|> match "text-array" IFTTextArray + +instance ToText IndexFieldType where + toText = \case + IFTDate -> "date" + IFTDateArray -> "date-array" + IFTDouble -> "double" + IFTDoubleArray -> "double-array" + IFTInt -> "int" + IFTIntArray -> "int-array" + IFTLatlon -> "latlon" + IFTLiteral -> "literal" + IFTLiteralArray -> "literal-array" + IFTText -> "text" + IFTTextArray -> "text-array" + +instance FromXML IndexFieldType where + parseXML = parseXMLText "IndexFieldType" + +instance ToQuery IndexFieldType where + toQuery = toQuery . toText + +data LatLonOptions = LatLonOptions + { _lloDefaultValue :: Maybe Text + , _lloFacetEnabled :: Maybe Bool + , _lloReturnEnabled :: Maybe Bool + , _lloSearchEnabled :: Maybe Bool + , _lloSortEnabled :: Maybe Bool + , _lloSourceField :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'LatLonOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'lloDefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'lloFacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'lloReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'lloSearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'lloSortEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'lloSourceField' @::@ 'Maybe' 'Text' +-- +latLonOptions :: LatLonOptions +latLonOptions = LatLonOptions + { _lloDefaultValue = Nothing + , _lloSourceField = Nothing + , _lloFacetEnabled = Nothing + , _lloSearchEnabled = Nothing + , _lloReturnEnabled = Nothing + , _lloSortEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +lloDefaultValue :: Lens' LatLonOptions (Maybe Text) +lloDefaultValue = lens _lloDefaultValue (\s a -> s { _lloDefaultValue = a }) + +-- | Whether facet information can be returned for the field. +lloFacetEnabled :: Lens' LatLonOptions (Maybe Bool) +lloFacetEnabled = lens _lloFacetEnabled (\s a -> s { _lloFacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +lloReturnEnabled :: Lens' LatLonOptions (Maybe Bool) +lloReturnEnabled = lens _lloReturnEnabled (\s a -> s { _lloReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +lloSearchEnabled :: Lens' LatLonOptions (Maybe Bool) +lloSearchEnabled = lens _lloSearchEnabled (\s a -> s { _lloSearchEnabled = a }) + +-- | Whether the field can be used to sort the search results. +lloSortEnabled :: Lens' LatLonOptions (Maybe Bool) +lloSortEnabled = lens _lloSortEnabled (\s a -> s { _lloSortEnabled = a }) + +lloSourceField :: Lens' LatLonOptions (Maybe Text) +lloSourceField = lens _lloSourceField (\s a -> s { _lloSourceField = a }) + +instance FromXML LatLonOptions where + parseXML x = LatLonOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SortEnabled" + <*> x .@? "SourceField" + +instance ToQuery LatLonOptions where + toQuery LatLonOptions{..} = mconcat + [ "DefaultValue" =? _lloDefaultValue + , "FacetEnabled" =? _lloFacetEnabled + , "ReturnEnabled" =? _lloReturnEnabled + , "SearchEnabled" =? _lloSearchEnabled + , "SortEnabled" =? _lloSortEnabled + , "SourceField" =? _lloSourceField + ] + +data SuggesterStatus = SuggesterStatus + { _ssOptions :: Suggester + , _ssStatus :: OptionStatus + } deriving (Eq, Show) + +-- | 'SuggesterStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ssOptions' @::@ 'Suggester' +-- +-- * 'ssStatus' @::@ 'OptionStatus' +-- +suggesterStatus :: Suggester -- ^ 'ssOptions' + -> OptionStatus -- ^ 'ssStatus' + -> SuggesterStatus +suggesterStatus p1 p2 = SuggesterStatus + { _ssOptions = p1 + , _ssStatus = p2 + } + +ssOptions :: Lens' SuggesterStatus Suggester +ssOptions = lens _ssOptions (\s a -> s { _ssOptions = a }) + +ssStatus :: Lens' SuggesterStatus OptionStatus +ssStatus = lens _ssStatus (\s a -> s { _ssStatus = a }) + +instance FromXML SuggesterStatus where + parseXML x = SuggesterStatus + <$> x .@ "Options" + <*> x .@ "Status" + +instance ToQuery SuggesterStatus where + toQuery SuggesterStatus{..} = mconcat + [ "Options" =? _ssOptions + , "Status" =? _ssStatus + ] + +data OptionStatus = OptionStatus + { _osCreationDate :: RFC822 + , _osPendingDeletion :: Maybe Bool + , _osState :: Text + , _osUpdateDate :: RFC822 + , _osUpdateVersion :: Maybe Nat + } deriving (Eq, Ord, Show) + +-- | 'OptionStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'osCreationDate' @::@ 'UTCTime' +-- +-- * 'osPendingDeletion' @::@ 'Maybe' 'Bool' +-- +-- * 'osState' @::@ 'Text' +-- +-- * 'osUpdateDate' @::@ 'UTCTime' +-- +-- * 'osUpdateVersion' @::@ 'Maybe' 'Natural' +-- +optionStatus :: UTCTime -- ^ 'osCreationDate' + -> UTCTime -- ^ 'osUpdateDate' + -> Text -- ^ 'osState' + -> OptionStatus +optionStatus p1 p2 p3 = OptionStatus + { _osCreationDate = withIso _Time (const id) p1 + , _osUpdateDate = withIso _Time (const id) p2 + , _osState = p3 + , _osUpdateVersion = Nothing + , _osPendingDeletion = Nothing + } + +-- | A timestamp for when this option was created. +osCreationDate :: Lens' OptionStatus UTCTime +osCreationDate = lens _osCreationDate (\s a -> s { _osCreationDate = a }) . _Time + +-- | Indicates that the option will be deleted once processing is complete. +osPendingDeletion :: Lens' OptionStatus (Maybe Bool) +osPendingDeletion = + lens _osPendingDeletion (\s a -> s { _osPendingDeletion = a }) + +-- | The state of processing a change to an option. Possible values: +-- RequiresIndexDocuments: the option's latest value will not be deployed +-- until IndexDocuments has been called and indexing is complete. +-- Processing: the option's latest value is in the process of being +-- activated. Active: the option's latest value is completely deployed. +-- FailedToValidate: the option value is not compatible with the domain's +-- data and cannot be used to index the data. You must either modify the +-- option value or update or remove the incompatible documents. +osState :: Lens' OptionStatus Text +osState = lens _osState (\s a -> s { _osState = a }) + +-- | A timestamp for when this option was last updated. +osUpdateDate :: Lens' OptionStatus UTCTime +osUpdateDate = lens _osUpdateDate (\s a -> s { _osUpdateDate = a }) . _Time + +-- | A unique integer that indicates when this option was last updated. +osUpdateVersion :: Lens' OptionStatus (Maybe Natural) +osUpdateVersion = lens _osUpdateVersion (\s a -> s { _osUpdateVersion = a }) . mapping _Nat + +instance FromXML OptionStatus where + parseXML x = OptionStatus + <$> x .@ "CreationDate" + <*> x .@? "PendingDeletion" + <*> x .@ "State" + <*> x .@ "UpdateDate" + <*> x .@? "UpdateVersion" + +instance ToQuery OptionStatus where + toQuery OptionStatus{..} = mconcat + [ "CreationDate" =? _osCreationDate + , "PendingDeletion" =? _osPendingDeletion + , "State" =? _osState + , "UpdateDate" =? _osUpdateDate + , "UpdateVersion" =? _osUpdateVersion + ] + +data LiteralArrayOptions = LiteralArrayOptions + { _laoDefaultValue :: Maybe Text + , _laoFacetEnabled :: Maybe Bool + , _laoReturnEnabled :: Maybe Bool + , _laoSearchEnabled :: Maybe Bool + , _laoSourceFields :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'LiteralArrayOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'laoDefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'laoFacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'laoReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'laoSearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'laoSourceFields' @::@ 'Maybe' 'Text' +-- +literalArrayOptions :: LiteralArrayOptions +literalArrayOptions = LiteralArrayOptions + { _laoDefaultValue = Nothing + , _laoSourceFields = Nothing + , _laoFacetEnabled = Nothing + , _laoSearchEnabled = Nothing + , _laoReturnEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +laoDefaultValue :: Lens' LiteralArrayOptions (Maybe Text) +laoDefaultValue = lens _laoDefaultValue (\s a -> s { _laoDefaultValue = a }) + +-- | Whether facet information can be returned for the field. +laoFacetEnabled :: Lens' LiteralArrayOptions (Maybe Bool) +laoFacetEnabled = lens _laoFacetEnabled (\s a -> s { _laoFacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +laoReturnEnabled :: Lens' LiteralArrayOptions (Maybe Bool) +laoReturnEnabled = lens _laoReturnEnabled (\s a -> s { _laoReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +laoSearchEnabled :: Lens' LiteralArrayOptions (Maybe Bool) +laoSearchEnabled = lens _laoSearchEnabled (\s a -> s { _laoSearchEnabled = a }) + +-- | A list of source fields to map to the field. +laoSourceFields :: Lens' LiteralArrayOptions (Maybe Text) +laoSourceFields = lens _laoSourceFields (\s a -> s { _laoSourceFields = a }) + +instance FromXML LiteralArrayOptions where + parseXML x = LiteralArrayOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SourceFields" + +instance ToQuery LiteralArrayOptions where + toQuery LiteralArrayOptions{..} = mconcat + [ "DefaultValue" =? _laoDefaultValue + , "FacetEnabled" =? _laoFacetEnabled + , "ReturnEnabled" =? _laoReturnEnabled + , "SearchEnabled" =? _laoSearchEnabled + , "SourceFields" =? _laoSourceFields + ] + +data IntArrayOptions = IntArrayOptions + { _iaoDefaultValue :: Maybe Integer + , _iaoFacetEnabled :: Maybe Bool + , _iaoReturnEnabled :: Maybe Bool + , _iaoSearchEnabled :: Maybe Bool + , _iaoSourceFields :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'IntArrayOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'iaoDefaultValue' @::@ 'Maybe' 'Integer' +-- +-- * 'iaoFacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'iaoReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'iaoSearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'iaoSourceFields' @::@ 'Maybe' 'Text' +-- +intArrayOptions :: IntArrayOptions +intArrayOptions = IntArrayOptions + { _iaoDefaultValue = Nothing + , _iaoSourceFields = Nothing + , _iaoFacetEnabled = Nothing + , _iaoSearchEnabled = Nothing + , _iaoReturnEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +iaoDefaultValue :: Lens' IntArrayOptions (Maybe Integer) +iaoDefaultValue = lens _iaoDefaultValue (\s a -> s { _iaoDefaultValue = a }) + +-- | Whether facet information can be returned for the field. +iaoFacetEnabled :: Lens' IntArrayOptions (Maybe Bool) +iaoFacetEnabled = lens _iaoFacetEnabled (\s a -> s { _iaoFacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +iaoReturnEnabled :: Lens' IntArrayOptions (Maybe Bool) +iaoReturnEnabled = lens _iaoReturnEnabled (\s a -> s { _iaoReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +iaoSearchEnabled :: Lens' IntArrayOptions (Maybe Bool) +iaoSearchEnabled = lens _iaoSearchEnabled (\s a -> s { _iaoSearchEnabled = a }) + +-- | A list of source fields to map to the field. +iaoSourceFields :: Lens' IntArrayOptions (Maybe Text) +iaoSourceFields = lens _iaoSourceFields (\s a -> s { _iaoSourceFields = a }) + +instance FromXML IntArrayOptions where + parseXML x = IntArrayOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SourceFields" + +instance ToQuery IntArrayOptions where + toQuery IntArrayOptions{..} = mconcat + [ "DefaultValue" =? _iaoDefaultValue + , "FacetEnabled" =? _iaoFacetEnabled + , "ReturnEnabled" =? _iaoReturnEnabled + , "SearchEnabled" =? _iaoSearchEnabled + , "SourceFields" =? _iaoSourceFields + ] + +data Expression = Expression + { _eExpressionName :: Text + , _eExpressionValue :: Text + } deriving (Eq, Ord, Show) + +-- | 'Expression' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'eExpressionName' @::@ 'Text' +-- +-- * 'eExpressionValue' @::@ 'Text' +-- +expression :: Text -- ^ 'eExpressionName' + -> Text -- ^ 'eExpressionValue' + -> Expression +expression p1 p2 = Expression + { _eExpressionName = p1 + , _eExpressionValue = p2 + } + +eExpressionName :: Lens' Expression Text +eExpressionName = lens _eExpressionName (\s a -> s { _eExpressionName = a }) + +eExpressionValue :: Lens' Expression Text +eExpressionValue = lens _eExpressionValue (\s a -> s { _eExpressionValue = a }) + +instance FromXML Expression where + parseXML x = Expression + <$> x .@ "ExpressionName" + <*> x .@ "ExpressionValue" + +instance ToQuery Expression where + toQuery Expression{..} = mconcat + [ "ExpressionName" =? _eExpressionName + , "ExpressionValue" =? _eExpressionValue + ] + +data SuggesterFuzzyMatching + = SFMHigh -- ^ high + | SFMLow -- ^ low + | SFMNone -- ^ none + deriving (Eq, Ord, Show, Generic, Enum) + +instance Hashable SuggesterFuzzyMatching + +instance FromText SuggesterFuzzyMatching where + parser = match "high" SFMHigh + <|> match "low" SFMLow + <|> match "none" SFMNone + +instance ToText SuggesterFuzzyMatching where + toText = \case + SFMHigh -> "high" + SFMLow -> "low" + SFMNone -> "none" + +instance FromXML SuggesterFuzzyMatching where + parseXML = parseXMLText "SuggesterFuzzyMatching" + +instance ToQuery SuggesterFuzzyMatching where + toQuery = toQuery . toText + +data DateArrayOptions = DateArrayOptions + { _dao1DefaultValue :: Maybe Text + , _dao1FacetEnabled :: Maybe Bool + , _dao1ReturnEnabled :: Maybe Bool + , _dao1SearchEnabled :: Maybe Bool + , _dao1SourceFields :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'DateArrayOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'dao1DefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'dao1FacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'dao1ReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'dao1SearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'dao1SourceFields' @::@ 'Maybe' 'Text' +-- +dateArrayOptions :: DateArrayOptions +dateArrayOptions = DateArrayOptions + { _dao1DefaultValue = Nothing + , _dao1SourceFields = Nothing + , _dao1FacetEnabled = Nothing + , _dao1SearchEnabled = Nothing + , _dao1ReturnEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +dao1DefaultValue :: Lens' DateArrayOptions (Maybe Text) +dao1DefaultValue = lens _dao1DefaultValue (\s a -> s { _dao1DefaultValue = a }) + +-- | Whether facet information can be returned for the field. +dao1FacetEnabled :: Lens' DateArrayOptions (Maybe Bool) +dao1FacetEnabled = lens _dao1FacetEnabled (\s a -> s { _dao1FacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +dao1ReturnEnabled :: Lens' DateArrayOptions (Maybe Bool) +dao1ReturnEnabled = + lens _dao1ReturnEnabled (\s a -> s { _dao1ReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +dao1SearchEnabled :: Lens' DateArrayOptions (Maybe Bool) +dao1SearchEnabled = + lens _dao1SearchEnabled (\s a -> s { _dao1SearchEnabled = a }) + +-- | A list of source fields to map to the field. +dao1SourceFields :: Lens' DateArrayOptions (Maybe Text) +dao1SourceFields = lens _dao1SourceFields (\s a -> s { _dao1SourceFields = a }) + +instance FromXML DateArrayOptions where + parseXML x = DateArrayOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SourceFields" + +instance ToQuery DateArrayOptions where + toQuery DateArrayOptions{..} = mconcat + [ "DefaultValue" =? _dao1DefaultValue + , "FacetEnabled" =? _dao1FacetEnabled + , "ReturnEnabled" =? _dao1ReturnEnabled + , "SearchEnabled" =? _dao1SearchEnabled + , "SourceFields" =? _dao1SourceFields + ] + +data AnalysisSchemeLanguage + = Ar -- ^ ar + | Bg -- ^ bg + | Ca -- ^ ca + | Cs -- ^ cs + | Da -- ^ da + | De -- ^ de + | El -- ^ el + | En -- ^ en + | Es -- ^ es + | Eu -- ^ eu + | Fa -- ^ fa + | Fi -- ^ fi + | Fr -- ^ fr + | Ga -- ^ ga + | Gl -- ^ gl + | He -- ^ he + | Hi -- ^ hi + | Hu -- ^ hu + | Hy -- ^ hy + | Id -- ^ id + | It -- ^ it + | Ja -- ^ ja + | Ko -- ^ ko + | Lv -- ^ lv + | Mul -- ^ mul + | Nl -- ^ nl + | No -- ^ no + | Pt -- ^ pt + | Ro -- ^ ro + | Ru -- ^ ru + | Sv -- ^ sv + | Th -- ^ th + | Tr -- ^ tr + | ZhHans -- ^ zh-Hans + | ZhHant -- ^ zh-Hant + deriving (Eq, Ord, Show, Generic, Enum) + +instance Hashable AnalysisSchemeLanguage + +instance FromText AnalysisSchemeLanguage where + parser = match "ar" Ar + <|> match "bg" Bg + <|> match "ca" Ca + <|> match "cs" Cs + <|> match "da" Da + <|> match "de" De + <|> match "el" El + <|> match "en" En + <|> match "es" Es + <|> match "eu" Eu + <|> match "fa" Fa + <|> match "fi" Fi + <|> match "fr" Fr + <|> match "ga" Ga + <|> match "gl" Gl + <|> match "he" He + <|> match "hi" Hi + <|> match "hu" Hu + <|> match "hy" Hy + <|> match "id" Id + <|> match "it" It + <|> match "ja" Ja + <|> match "ko" Ko + <|> match "lv" Lv + <|> match "mul" Mul + <|> match "nl" Nl + <|> match "no" No + <|> match "pt" Pt + <|> match "ro" Ro + <|> match "ru" Ru + <|> match "sv" Sv + <|> match "th" Th + <|> match "tr" Tr + <|> match "zh-Hans" ZhHans + <|> match "zh-Hant" ZhHant + +instance ToText AnalysisSchemeLanguage where + toText = \case + Ar -> "ar" + Bg -> "bg" + Ca -> "ca" + Cs -> "cs" + Da -> "da" + De -> "de" + El -> "el" + En -> "en" + Es -> "es" + Eu -> "eu" + Fa -> "fa" + Fi -> "fi" + Fr -> "fr" + Ga -> "ga" + Gl -> "gl" + He -> "he" + Hi -> "hi" + Hu -> "hu" + Hy -> "hy" + Id -> "id" + It -> "it" + Ja -> "ja" + Ko -> "ko" + Lv -> "lv" + Mul -> "mul" + Nl -> "nl" + No -> "no" + Pt -> "pt" + Ro -> "ro" + Ru -> "ru" + Sv -> "sv" + Th -> "th" + Tr -> "tr" + ZhHans -> "zh-Hans" + ZhHant -> "zh-Hant" + +instance FromXML AnalysisSchemeLanguage where + parseXML = parseXMLText "AnalysisSchemeLanguage" + +instance ToQuery AnalysisSchemeLanguage where + toQuery = toQuery . toText + +data PartitionInstanceType + = SearchM1Large -- ^ search.m1.large + | SearchM1Small -- ^ search.m1.small + | SearchM22XLarge -- ^ search.m2.2xlarge + | SearchM2XLarge -- ^ search.m2.xlarge + deriving (Eq, Ord, Show, Generic, Enum) + +instance Hashable PartitionInstanceType + +instance FromText PartitionInstanceType where + parser = match "search.m1.large" SearchM1Large + <|> match "search.m1.small" SearchM1Small + <|> match "search.m2.2xlarge" SearchM22XLarge + <|> match "search.m2.xlarge" SearchM2XLarge + +instance ToText PartitionInstanceType where + toText = \case + SearchM1Large -> "search.m1.large" + SearchM1Small -> "search.m1.small" + SearchM22XLarge -> "search.m2.2xlarge" + SearchM2XLarge -> "search.m2.xlarge" + +instance FromXML PartitionInstanceType where + parseXML = parseXMLText "PartitionInstanceType" + +instance ToQuery PartitionInstanceType where + toQuery = toQuery . toText + +data Suggester = Suggester + { _sDocumentSuggesterOptions :: DocumentSuggesterOptions + , _sSuggesterName :: Text + } deriving (Eq, Show) + +-- | 'Suggester' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'sDocumentSuggesterOptions' @::@ 'DocumentSuggesterOptions' +-- +-- * 'sSuggesterName' @::@ 'Text' +-- +suggester :: Text -- ^ 'sSuggesterName' + -> DocumentSuggesterOptions -- ^ 'sDocumentSuggesterOptions' + -> Suggester +suggester p1 p2 = Suggester + { _sSuggesterName = p1 + , _sDocumentSuggesterOptions = p2 + } + +sDocumentSuggesterOptions :: Lens' Suggester DocumentSuggesterOptions +sDocumentSuggesterOptions = + lens _sDocumentSuggesterOptions + (\s a -> s { _sDocumentSuggesterOptions = a }) + +sSuggesterName :: Lens' Suggester Text +sSuggesterName = lens _sSuggesterName (\s a -> s { _sSuggesterName = a }) + +instance FromXML Suggester where + parseXML x = Suggester + <$> x .@ "DocumentSuggesterOptions" + <*> x .@ "SuggesterName" + +instance ToQuery Suggester where + toQuery Suggester{..} = mconcat + [ "DocumentSuggesterOptions" =? _sDocumentSuggesterOptions + , "SuggesterName" =? _sSuggesterName + ] + +data IntOptions = IntOptions + { _ioDefaultValue :: Maybe Integer + , _ioFacetEnabled :: Maybe Bool + , _ioReturnEnabled :: Maybe Bool + , _ioSearchEnabled :: Maybe Bool + , _ioSortEnabled :: Maybe Bool + , _ioSourceField :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'IntOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'ioDefaultValue' @::@ 'Maybe' 'Integer' +-- +-- * 'ioFacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'ioReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'ioSearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'ioSortEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'ioSourceField' @::@ 'Maybe' 'Text' +-- +intOptions :: IntOptions +intOptions = IntOptions + { _ioDefaultValue = Nothing + , _ioSourceField = Nothing + , _ioFacetEnabled = Nothing + , _ioSearchEnabled = Nothing + , _ioReturnEnabled = Nothing + , _ioSortEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +-- This can be important if you are using the field in an expression and +-- that field is not present in every document. +ioDefaultValue :: Lens' IntOptions (Maybe Integer) +ioDefaultValue = lens _ioDefaultValue (\s a -> s { _ioDefaultValue = a }) + +-- | Whether facet information can be returned for the field. +ioFacetEnabled :: Lens' IntOptions (Maybe Bool) +ioFacetEnabled = lens _ioFacetEnabled (\s a -> s { _ioFacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +ioReturnEnabled :: Lens' IntOptions (Maybe Bool) +ioReturnEnabled = lens _ioReturnEnabled (\s a -> s { _ioReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +ioSearchEnabled :: Lens' IntOptions (Maybe Bool) +ioSearchEnabled = lens _ioSearchEnabled (\s a -> s { _ioSearchEnabled = a }) + +-- | Whether the field can be used to sort the search results. +ioSortEnabled :: Lens' IntOptions (Maybe Bool) +ioSortEnabled = lens _ioSortEnabled (\s a -> s { _ioSortEnabled = a }) + +-- | The name of the source field to map to the field. +ioSourceField :: Lens' IntOptions (Maybe Text) +ioSourceField = lens _ioSourceField (\s a -> s { _ioSourceField = a }) + +instance FromXML IntOptions where + parseXML x = IntOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SortEnabled" + <*> x .@? "SourceField" + +instance ToQuery IntOptions where + toQuery IntOptions{..} = mconcat + [ "DefaultValue" =? _ioDefaultValue + , "FacetEnabled" =? _ioFacetEnabled + , "ReturnEnabled" =? _ioReturnEnabled + , "SearchEnabled" =? _ioSearchEnabled + , "SortEnabled" =? _ioSortEnabled + , "SourceField" =? _ioSourceField + ] + +data LiteralOptions = LiteralOptions + { _loDefaultValue :: Maybe Text + , _loFacetEnabled :: Maybe Bool + , _loReturnEnabled :: Maybe Bool + , _loSearchEnabled :: Maybe Bool + , _loSortEnabled :: Maybe Bool + , _loSourceField :: Maybe Text + } deriving (Eq, Ord, Show) + +-- | 'LiteralOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'loDefaultValue' @::@ 'Maybe' 'Text' +-- +-- * 'loFacetEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'loReturnEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'loSearchEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'loSortEnabled' @::@ 'Maybe' 'Bool' +-- +-- * 'loSourceField' @::@ 'Maybe' 'Text' +-- +literalOptions :: LiteralOptions +literalOptions = LiteralOptions + { _loDefaultValue = Nothing + , _loSourceField = Nothing + , _loFacetEnabled = Nothing + , _loSearchEnabled = Nothing + , _loReturnEnabled = Nothing + , _loSortEnabled = Nothing + } + +-- | A value to use for the field if the field isn't specified for a document. +loDefaultValue :: Lens' LiteralOptions (Maybe Text) +loDefaultValue = lens _loDefaultValue (\s a -> s { _loDefaultValue = a }) + +-- | Whether facet information can be returned for the field. +loFacetEnabled :: Lens' LiteralOptions (Maybe Bool) +loFacetEnabled = lens _loFacetEnabled (\s a -> s { _loFacetEnabled = a }) + +-- | Whether the contents of the field can be returned in the search results. +loReturnEnabled :: Lens' LiteralOptions (Maybe Bool) +loReturnEnabled = lens _loReturnEnabled (\s a -> s { _loReturnEnabled = a }) + +-- | Whether the contents of the field are searchable. +loSearchEnabled :: Lens' LiteralOptions (Maybe Bool) +loSearchEnabled = lens _loSearchEnabled (\s a -> s { _loSearchEnabled = a }) + +-- | Whether the field can be used to sort the search results. +loSortEnabled :: Lens' LiteralOptions (Maybe Bool) +loSortEnabled = lens _loSortEnabled (\s a -> s { _loSortEnabled = a }) + +loSourceField :: Lens' LiteralOptions (Maybe Text) +loSourceField = lens _loSourceField (\s a -> s { _loSourceField = a }) + +instance FromXML LiteralOptions where + parseXML x = LiteralOptions + <$> x .@? "DefaultValue" + <*> x .@? "FacetEnabled" + <*> x .@? "ReturnEnabled" + <*> x .@? "SearchEnabled" + <*> x .@? "SortEnabled" + <*> x .@? "SourceField" + +instance ToQuery LiteralOptions where + toQuery LiteralOptions{..} = mconcat + [ "DefaultValue" =? _loDefaultValue + , "FacetEnabled" =? _loFacetEnabled + , "ReturnEnabled" =? _loReturnEnabled + , "SearchEnabled" =? _loSearchEnabled + , "SortEnabled" =? _loSortEnabled + , "SourceField" =? _loSourceField + ] + +data AccessPoliciesStatus = AccessPoliciesStatus + { _apsOptions :: Text + , _apsStatus :: OptionStatus + } deriving (Eq, Show) + +-- | 'AccessPoliciesStatus' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'apsOptions' @::@ 'Text' +-- +-- * 'apsStatus' @::@ 'OptionStatus' +-- +accessPoliciesStatus :: Text -- ^ 'apsOptions' + -> OptionStatus -- ^ 'apsStatus' + -> AccessPoliciesStatus +accessPoliciesStatus p1 p2 = AccessPoliciesStatus + { _apsOptions = p1 + , _apsStatus = p2 + } + +apsOptions :: Lens' AccessPoliciesStatus Text +apsOptions = lens _apsOptions (\s a -> s { _apsOptions = a }) + +apsStatus :: Lens' AccessPoliciesStatus OptionStatus +apsStatus = lens _apsStatus (\s a -> s { _apsStatus = a }) + +instance FromXML AccessPoliciesStatus where + parseXML x = AccessPoliciesStatus + <$> x .@ "Options" + <*> x .@ "Status" + +instance ToQuery AccessPoliciesStatus where + toQuery AccessPoliciesStatus{..} = mconcat + [ "Options" =? _apsOptions + , "Status" =? _apsStatus + ] diff --git a/gen/Network/AWS/CloudSearch/UpdateAvailabilityOptions.hs b/gen/Network/AWS/CloudSearch/UpdateAvailabilityOptions.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/UpdateAvailabilityOptions.hs @@ -0,0 +1,126 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.UpdateAvailabilityOptions +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Configures the availability options for a domain. Enabling the Multi-AZ +-- option expands an Amazon CloudSearch domain to an additional Availability +-- Zone in the same Region to increase fault tolerance in the event of a +-- service disruption. Changes to the Multi-AZ option can take about half an +-- hour to become active. For more information, see Configuring Availability +-- Options in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.UpdateAvailabilityOptions + ( + -- * Request + UpdateAvailabilityOptions + -- ** Request constructor + , updateAvailabilityOptions + -- ** Request lenses + , uaoDomainName + , uaoMultiAZ + + -- * Response + , UpdateAvailabilityOptionsResponse + -- ** Response constructor + , updateAvailabilityOptionsResponse + -- ** Response lenses + , uaorAvailabilityOptions + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data UpdateAvailabilityOptions = UpdateAvailabilityOptions + { _uaoDomainName :: Text + , _uaoMultiAZ :: Bool + } deriving (Eq, Ord, Show) + +-- | 'UpdateAvailabilityOptions' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'uaoDomainName' @::@ 'Text' +-- +-- * 'uaoMultiAZ' @::@ 'Bool' +-- +updateAvailabilityOptions :: Text -- ^ 'uaoDomainName' + -> Bool -- ^ 'uaoMultiAZ' + -> UpdateAvailabilityOptions +updateAvailabilityOptions p1 p2 = UpdateAvailabilityOptions + { _uaoDomainName = p1 + , _uaoMultiAZ = p2 + } + +uaoDomainName :: Lens' UpdateAvailabilityOptions Text +uaoDomainName = lens _uaoDomainName (\s a -> s { _uaoDomainName = a }) + +-- | You expand an existing search domain to a second Availability Zone by +-- setting the Multi-AZ option to true. Similarly, you can turn off the +-- Multi-AZ option to downgrade the domain to a single Availability Zone by +-- setting the Multi-AZ option to false. +uaoMultiAZ :: Lens' UpdateAvailabilityOptions Bool +uaoMultiAZ = lens _uaoMultiAZ (\s a -> s { _uaoMultiAZ = a }) + +newtype UpdateAvailabilityOptionsResponse = UpdateAvailabilityOptionsResponse + { _uaorAvailabilityOptions :: Maybe AvailabilityOptionsStatus + } deriving (Eq, Show) + +-- | 'UpdateAvailabilityOptionsResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'uaorAvailabilityOptions' @::@ 'Maybe' 'AvailabilityOptionsStatus' +-- +updateAvailabilityOptionsResponse :: UpdateAvailabilityOptionsResponse +updateAvailabilityOptionsResponse = UpdateAvailabilityOptionsResponse + { _uaorAvailabilityOptions = Nothing + } + +-- | The newly-configured availability options. Indicates whether Multi-AZ is +-- enabled for the domain. +uaorAvailabilityOptions :: Lens' UpdateAvailabilityOptionsResponse (Maybe AvailabilityOptionsStatus) +uaorAvailabilityOptions = + lens _uaorAvailabilityOptions (\s a -> s { _uaorAvailabilityOptions = a }) + +instance ToPath UpdateAvailabilityOptions where + toPath = const "/" + +instance ToQuery UpdateAvailabilityOptions where + toQuery UpdateAvailabilityOptions{..} = mconcat + [ "DomainName" =? _uaoDomainName + , "MultiAZ" =? _uaoMultiAZ + ] + +instance ToHeaders UpdateAvailabilityOptions + +instance AWSRequest UpdateAvailabilityOptions where + type Sv UpdateAvailabilityOptions = CloudSearch + type Rs UpdateAvailabilityOptions = UpdateAvailabilityOptionsResponse + + request = post "UpdateAvailabilityOptions" + response = xmlResponse + +instance FromXML UpdateAvailabilityOptionsResponse where + parseXML = withElement "UpdateAvailabilityOptionsResult" $ \x -> UpdateAvailabilityOptionsResponse + <$> x .@? "AvailabilityOptions" diff --git a/gen/Network/AWS/CloudSearch/UpdateScalingParameters.hs b/gen/Network/AWS/CloudSearch/UpdateScalingParameters.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/UpdateScalingParameters.hs @@ -0,0 +1,123 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.UpdateScalingParameters +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Configures scaling parameters for a domain. A domain's scaling parameters +-- specify the desired search instance type and replication count. Amazon +-- CloudSearch will still automatically scale your domain based on the volume +-- of data and traffic, but not below the desired instance type and +-- replication count. If the Multi-AZ option is enabled, these values control +-- the resources used per Availability Zone. For more information, see +-- Configuring Scaling Options in the Amazon CloudSearch Developer Guide. +-- +-- +module Network.AWS.CloudSearch.UpdateScalingParameters + ( + -- * Request + UpdateScalingParameters + -- ** Request constructor + , updateScalingParameters + -- ** Request lenses + , uspDomainName + , uspScalingParameters + + -- * Response + , UpdateScalingParametersResponse + -- ** Response constructor + , updateScalingParametersResponse + -- ** Response lenses + , usprScalingParameters + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data UpdateScalingParameters = UpdateScalingParameters + { _uspDomainName :: Text + , _uspScalingParameters :: ScalingParameters + } deriving (Eq, Show) + +-- | 'UpdateScalingParameters' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'uspDomainName' @::@ 'Text' +-- +-- * 'uspScalingParameters' @::@ 'ScalingParameters' +-- +updateScalingParameters :: Text -- ^ 'uspDomainName' + -> ScalingParameters -- ^ 'uspScalingParameters' + -> UpdateScalingParameters +updateScalingParameters p1 p2 = UpdateScalingParameters + { _uspDomainName = p1 + , _uspScalingParameters = p2 + } + +uspDomainName :: Lens' UpdateScalingParameters Text +uspDomainName = lens _uspDomainName (\s a -> s { _uspDomainName = a }) + +uspScalingParameters :: Lens' UpdateScalingParameters ScalingParameters +uspScalingParameters = + lens _uspScalingParameters (\s a -> s { _uspScalingParameters = a }) + +newtype UpdateScalingParametersResponse = UpdateScalingParametersResponse + { _usprScalingParameters :: ScalingParametersStatus + } deriving (Eq, Show) + +-- | 'UpdateScalingParametersResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'usprScalingParameters' @::@ 'ScalingParametersStatus' +-- +updateScalingParametersResponse :: ScalingParametersStatus -- ^ 'usprScalingParameters' + -> UpdateScalingParametersResponse +updateScalingParametersResponse p1 = UpdateScalingParametersResponse + { _usprScalingParameters = p1 + } + +usprScalingParameters :: Lens' UpdateScalingParametersResponse ScalingParametersStatus +usprScalingParameters = + lens _usprScalingParameters (\s a -> s { _usprScalingParameters = a }) + +instance ToPath UpdateScalingParameters where + toPath = const "/" + +instance ToQuery UpdateScalingParameters where + toQuery UpdateScalingParameters{..} = mconcat + [ "DomainName" =? _uspDomainName + , "ScalingParameters" =? _uspScalingParameters + ] + +instance ToHeaders UpdateScalingParameters + +instance AWSRequest UpdateScalingParameters where + type Sv UpdateScalingParameters = CloudSearch + type Rs UpdateScalingParameters = UpdateScalingParametersResponse + + request = post "UpdateScalingParameters" + response = xmlResponse + +instance FromXML UpdateScalingParametersResponse where + parseXML = withElement "UpdateScalingParametersResult" $ \x -> UpdateScalingParametersResponse + <$> x .@ "ScalingParameters" diff --git a/gen/Network/AWS/CloudSearch/UpdateServiceAccessPolicies.hs b/gen/Network/AWS/CloudSearch/UpdateServiceAccessPolicies.hs new file mode 100644 --- /dev/null +++ b/gen/Network/AWS/CloudSearch/UpdateServiceAccessPolicies.hs @@ -0,0 +1,122 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- Module : Network.AWS.CloudSearch.UpdateServiceAccessPolicies +-- Copyright : (c) 2013-2014 Brendan Hay +-- License : This Source Code Form is subject to the terms of +-- the Mozilla Public License, v. 2.0. +-- A copy of the MPL can be found in the LICENSE file or +-- you can obtain it at http://mozilla.org/MPL/2.0/. +-- Maintainer : Brendan Hay +-- Stability : experimental +-- Portability : non-portable (GHC extensions) + +-- | Configures the access rules that control access to the domain's document +-- and search endpoints. For more information, see Configuring Access for an +-- Amazon CloudSearch Domain. +-- +-- +module Network.AWS.CloudSearch.UpdateServiceAccessPolicies + ( + -- * Request + UpdateServiceAccessPolicies + -- ** Request constructor + , updateServiceAccessPolicies + -- ** Request lenses + , usapAccessPolicies + , usapDomainName + + -- * Response + , UpdateServiceAccessPoliciesResponse + -- ** Response constructor + , updateServiceAccessPoliciesResponse + -- ** Response lenses + , usaprAccessPolicies + ) where + +import Network.AWS.Prelude +import Network.AWS.Request.Query +import Network.AWS.CloudSearch.Types +import qualified GHC.Exts + +data UpdateServiceAccessPolicies = UpdateServiceAccessPolicies + { _usapAccessPolicies :: Text + , _usapDomainName :: Text + } deriving (Eq, Ord, Show) + +-- | 'UpdateServiceAccessPolicies' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'usapAccessPolicies' @::@ 'Text' +-- +-- * 'usapDomainName' @::@ 'Text' +-- +updateServiceAccessPolicies :: Text -- ^ 'usapDomainName' + -> Text -- ^ 'usapAccessPolicies' + -> UpdateServiceAccessPolicies +updateServiceAccessPolicies p1 p2 = UpdateServiceAccessPolicies + { _usapDomainName = p1 + , _usapAccessPolicies = p2 + } + +-- | The access rules you want to configure. These rules replace any existing +-- rules. +usapAccessPolicies :: Lens' UpdateServiceAccessPolicies Text +usapAccessPolicies = + lens _usapAccessPolicies (\s a -> s { _usapAccessPolicies = a }) + +usapDomainName :: Lens' UpdateServiceAccessPolicies Text +usapDomainName = lens _usapDomainName (\s a -> s { _usapDomainName = a }) + +newtype UpdateServiceAccessPoliciesResponse = UpdateServiceAccessPoliciesResponse + { _usaprAccessPolicies :: AccessPoliciesStatus + } deriving (Eq, Show) + +-- | 'UpdateServiceAccessPoliciesResponse' constructor. +-- +-- The fields accessible through corresponding lenses are: +-- +-- * 'usaprAccessPolicies' @::@ 'AccessPoliciesStatus' +-- +updateServiceAccessPoliciesResponse :: AccessPoliciesStatus -- ^ 'usaprAccessPolicies' + -> UpdateServiceAccessPoliciesResponse +updateServiceAccessPoliciesResponse p1 = UpdateServiceAccessPoliciesResponse + { _usaprAccessPolicies = p1 + } + +-- | The access rules configured for the domain. +usaprAccessPolicies :: Lens' UpdateServiceAccessPoliciesResponse AccessPoliciesStatus +usaprAccessPolicies = + lens _usaprAccessPolicies (\s a -> s { _usaprAccessPolicies = a }) + +instance ToPath UpdateServiceAccessPolicies where + toPath = const "/" + +instance ToQuery UpdateServiceAccessPolicies where + toQuery UpdateServiceAccessPolicies{..} = mconcat + [ "AccessPolicies" =? _usapAccessPolicies + , "DomainName" =? _usapDomainName + ] + +instance ToHeaders UpdateServiceAccessPolicies + +instance AWSRequest UpdateServiceAccessPolicies where + type Sv UpdateServiceAccessPolicies = CloudSearch + type Rs UpdateServiceAccessPolicies = UpdateServiceAccessPoliciesResponse + + request = post "UpdateServiceAccessPolicies" + response = xmlResponse + +instance FromXML UpdateServiceAccessPoliciesResponse where + parseXML = withElement "UpdateServiceAccessPoliciesResult" $ \x -> UpdateServiceAccessPoliciesResponse + <$> x .@ "AccessPolicies"