module Network.AWS.CloudSearch.Types
(
CloudSearch
, RESTError
, ns
, DomainStatus
, domainStatus
, dsARN
, dsCreated
, dsDeleted
, dsDocService
, dsDomainId
, dsDomainName
, dsLimits
, dsProcessing
, dsRequiresIndexDocuments
, dsSearchInstanceCount
, dsSearchInstanceType
, dsSearchPartitionCount
, dsSearchService
, DocumentSuggesterOptions
, documentSuggesterOptions
, dsoFuzzyMatching
, dsoSortExpression
, dsoSourceField
, DoubleArrayOptions
, doubleArrayOptions
, daoDefaultValue
, daoFacetEnabled
, daoReturnEnabled
, daoSearchEnabled
, daoSourceFields
, IndexField
, indexField
, ifDateArrayOptions
, ifDateOptions
, ifDoubleArrayOptions
, ifDoubleOptions
, ifIndexFieldName
, ifIndexFieldType
, ifIntArrayOptions
, ifIntOptions
, ifLatLonOptions
, ifLiteralArrayOptions
, ifLiteralOptions
, ifTextArrayOptions
, ifTextOptions
, DateOptions
, dateOptions
, doDefaultValue
, doFacetEnabled
, doReturnEnabled
, doSearchEnabled
, doSortEnabled
, doSourceField
, OptionState (..)
, TextArrayOptions
, textArrayOptions
, taoAnalysisScheme
, taoDefaultValue
, taoHighlightEnabled
, taoReturnEnabled
, taoSourceFields
, AlgorithmicStemming (..)
, AnalysisScheme
, analysisScheme
, asAnalysisOptions
, asAnalysisSchemeLanguage
, asAnalysisSchemeName
, ScalingParameters
, scalingParameters
, spDesiredInstanceType
, spDesiredPartitionCount
, spDesiredReplicationCount
, AnalysisOptions
, analysisOptions
, aoAlgorithmicStemming
, aoJapaneseTokenizationDictionary
, aoStemmingDictionary
, aoStopwords
, aoSynonyms
, DoubleOptions
, doubleOptions
, do1DefaultValue
, do1FacetEnabled
, do1ReturnEnabled
, do1SearchEnabled
, do1SortEnabled
, do1SourceField
, TextOptions
, textOptions
, toAnalysisScheme
, toDefaultValue
, toHighlightEnabled
, toReturnEnabled
, toSortEnabled
, toSourceField
, AvailabilityOptionsStatus
, availabilityOptionsStatus
, aosOptions
, aosStatus
, IndexFieldStatus
, indexFieldStatus
, ifsOptions
, ifsStatus
, ScalingParametersStatus
, scalingParametersStatus
, spsOptions
, spsStatus
, AnalysisSchemeStatus
, analysisSchemeStatus
, assOptions
, assStatus
, ServiceEndpoint
, serviceEndpoint
, seEndpoint
, Limits
, limits
, lMaximumPartitionCount
, lMaximumReplicationCount
, ExpressionStatus
, expressionStatus
, esOptions
, esStatus
, IndexFieldType (..)
, LatLonOptions
, latLonOptions
, lloDefaultValue
, lloFacetEnabled
, lloReturnEnabled
, lloSearchEnabled
, lloSortEnabled
, lloSourceField
, SuggesterStatus
, suggesterStatus
, ssOptions
, ssStatus
, OptionStatus
, optionStatus
, osCreationDate
, osPendingDeletion
, osState
, osUpdateDate
, osUpdateVersion
, LiteralArrayOptions
, literalArrayOptions
, laoDefaultValue
, laoFacetEnabled
, laoReturnEnabled
, laoSearchEnabled
, laoSourceFields
, IntArrayOptions
, intArrayOptions
, iaoDefaultValue
, iaoFacetEnabled
, iaoReturnEnabled
, iaoSearchEnabled
, iaoSourceFields
, Expression
, expression
, eExpressionName
, eExpressionValue
, SuggesterFuzzyMatching (..)
, DateArrayOptions
, dateArrayOptions
, dao1DefaultValue
, dao1FacetEnabled
, dao1ReturnEnabled
, dao1SearchEnabled
, dao1SourceFields
, AnalysisSchemeLanguage (..)
, PartitionInstanceType (..)
, Suggester
, suggester
, sDocumentSuggesterOptions
, sSuggesterName
, IntOptions
, intOptions
, ioDefaultValue
, ioFacetEnabled
, ioReturnEnabled
, ioSearchEnabled
, ioSortEnabled
, ioSourceField
, LiteralOptions
, literalOptions
, loDefaultValue
, loFacetEnabled
, loReturnEnabled
, loSearchEnabled
, loSortEnabled
, loSourceField
, AccessPoliciesStatus
, accessPoliciesStatus
, apsOptions
, apsStatus
) where
import Network.AWS.Prelude
import Network.AWS.Signing
import qualified GHC.Exts
data CloudSearch
instance AWSService CloudSearch where
type Sg CloudSearch = V4
type Er CloudSearch = RESTError
service = service'
where
service' :: Service CloudSearch
service' = Service
{ _svcAbbrev = "CloudSearch"
, _svcPrefix = "cloudsearch"
, _svcVersion = "2013-01-01"
, _svcTargetPrefix = Nothing
, _svcJSONVersion = Nothing
, _svcHandle = handle
, _svcRetry = retry
}
handle :: Status
-> Maybe (LazyByteString -> ServiceError RESTError)
handle = restError statusSuccess service'
retry :: Retry CloudSearch
retry = Exponential
{ _retryBase = 0.05
, _retryGrowth = 2
, _retryAttempts = 5
, _retryCheck = check
}
check :: Status
-> RESTError
-> Bool
check (statusCode -> s) (awsErrorCode -> e)
| s == 509 && "BandwidthLimitExceeded" == e = True
| s == 500 = True
| s == 509 = True
| s == 503 = True
| otherwise = False
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, Read, Show)
domainStatus :: Text
-> Text
-> Bool
-> 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 })
dsCreated :: Lens' DomainStatus (Maybe Bool)
dsCreated = lens _dsCreated (\s a -> s { _dsCreated = a })
dsDeleted :: Lens' DomainStatus (Maybe Bool)
dsDeleted = lens _dsDeleted (\s a -> s { _dsDeleted = a })
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 })
dsProcessing :: Lens' DomainStatus (Maybe Bool)
dsProcessing = lens _dsProcessing (\s a -> s { _dsProcessing = a })
dsRequiresIndexDocuments :: Lens' DomainStatus Bool
dsRequiresIndexDocuments =
lens _dsRequiresIndexDocuments
(\s a -> s { _dsRequiresIndexDocuments = a })
dsSearchInstanceCount :: Lens' DomainStatus (Maybe Natural)
dsSearchInstanceCount =
lens _dsSearchInstanceCount (\s a -> s { _dsSearchInstanceCount = a })
. mapping _Nat
dsSearchInstanceType :: Lens' DomainStatus (Maybe Text)
dsSearchInstanceType =
lens _dsSearchInstanceType (\s a -> s { _dsSearchInstanceType = a })
dsSearchPartitionCount :: Lens' DomainStatus (Maybe Natural)
dsSearchPartitionCount =
lens _dsSearchPartitionCount (\s a -> s { _dsSearchPartitionCount = a })
. mapping _Nat
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 SuggesterFuzzyMatching
, _dsoSortExpression :: Maybe Text
, _dsoSourceField :: Text
} deriving (Eq, Read, Show)
documentSuggesterOptions :: Text
-> DocumentSuggesterOptions
documentSuggesterOptions p1 = DocumentSuggesterOptions
{ _dsoSourceField = p1
, _dsoFuzzyMatching = Nothing
, _dsoSortExpression = Nothing
}
dsoFuzzyMatching :: Lens' DocumentSuggesterOptions (Maybe SuggesterFuzzyMatching)
dsoFuzzyMatching = lens _dsoFuzzyMatching (\s a -> s { _dsoFuzzyMatching = a })
dsoSortExpression :: Lens' DocumentSuggesterOptions (Maybe Text)
dsoSortExpression =
lens _dsoSortExpression (\s a -> s { _dsoSortExpression = a })
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, Read, Show)
doubleArrayOptions :: DoubleArrayOptions
doubleArrayOptions = DoubleArrayOptions
{ _daoDefaultValue = Nothing
, _daoSourceFields = Nothing
, _daoFacetEnabled = Nothing
, _daoSearchEnabled = Nothing
, _daoReturnEnabled = Nothing
}
daoDefaultValue :: Lens' DoubleArrayOptions (Maybe Double)
daoDefaultValue = lens _daoDefaultValue (\s a -> s { _daoDefaultValue = a })
daoFacetEnabled :: Lens' DoubleArrayOptions (Maybe Bool)
daoFacetEnabled = lens _daoFacetEnabled (\s a -> s { _daoFacetEnabled = a })
daoReturnEnabled :: Lens' DoubleArrayOptions (Maybe Bool)
daoReturnEnabled = lens _daoReturnEnabled (\s a -> s { _daoReturnEnabled = a })
daoSearchEnabled :: Lens' DoubleArrayOptions (Maybe Bool)
daoSearchEnabled = lens _daoSearchEnabled (\s a -> s { _daoSearchEnabled = a })
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 :: IndexFieldType
, _ifIntArrayOptions :: Maybe IntArrayOptions
, _ifIntOptions :: Maybe IntOptions
, _ifLatLonOptions :: Maybe LatLonOptions
, _ifLiteralArrayOptions :: Maybe LiteralArrayOptions
, _ifLiteralOptions :: Maybe LiteralOptions
, _ifTextArrayOptions :: Maybe TextArrayOptions
, _ifTextOptions :: Maybe TextOptions
} deriving (Eq, Read, Show)
indexField :: Text
-> IndexFieldType
-> 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 })
ifIndexFieldName :: Lens' IndexField Text
ifIndexFieldName = lens _ifIndexFieldName (\s a -> s { _ifIndexFieldName = a })
ifIndexFieldType :: Lens' IndexField IndexFieldType
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, Read, Show)
dateOptions :: DateOptions
dateOptions = DateOptions
{ _doDefaultValue = Nothing
, _doSourceField = Nothing
, _doFacetEnabled = Nothing
, _doSearchEnabled = Nothing
, _doReturnEnabled = Nothing
, _doSortEnabled = Nothing
}
doDefaultValue :: Lens' DateOptions (Maybe Text)
doDefaultValue = lens _doDefaultValue (\s a -> s { _doDefaultValue = a })
doFacetEnabled :: Lens' DateOptions (Maybe Bool)
doFacetEnabled = lens _doFacetEnabled (\s a -> s { _doFacetEnabled = a })
doReturnEnabled :: Lens' DateOptions (Maybe Bool)
doReturnEnabled = lens _doReturnEnabled (\s a -> s { _doReturnEnabled = a })
doSearchEnabled :: Lens' DateOptions (Maybe Bool)
doSearchEnabled = lens _doSearchEnabled (\s a -> s { _doSearchEnabled = a })
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
| FailedToValidate
| Processing
| RequiresIndexDocuments
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable OptionState
instance FromText OptionState where
parser = takeLowerText >>= \case
"active" -> pure Active
"failedtovalidate" -> pure FailedToValidate
"processing" -> pure Processing
"requiresindexdocuments" -> pure RequiresIndexDocuments
e -> fail $
"Failure parsing OptionState from " ++ show e
instance ToText OptionState where
toText = \case
Active -> "Active"
FailedToValidate -> "FailedToValidate"
Processing -> "Processing"
RequiresIndexDocuments -> "RequiresIndexDocuments"
instance ToByteString OptionState
instance ToHeader OptionState
instance ToQuery OptionState
instance FromXML OptionState where
parseXML = parseXMLText "OptionState"
data TextArrayOptions = TextArrayOptions
{ _taoAnalysisScheme :: Maybe Text
, _taoDefaultValue :: Maybe Text
, _taoHighlightEnabled :: Maybe Bool
, _taoReturnEnabled :: Maybe Bool
, _taoSourceFields :: Maybe Text
} deriving (Eq, Ord, Read, Show)
textArrayOptions :: TextArrayOptions
textArrayOptions = TextArrayOptions
{ _taoDefaultValue = Nothing
, _taoSourceFields = Nothing
, _taoReturnEnabled = Nothing
, _taoHighlightEnabled = Nothing
, _taoAnalysisScheme = Nothing
}
taoAnalysisScheme :: Lens' TextArrayOptions (Maybe Text)
taoAnalysisScheme =
lens _taoAnalysisScheme (\s a -> s { _taoAnalysisScheme = a })
taoDefaultValue :: Lens' TextArrayOptions (Maybe Text)
taoDefaultValue = lens _taoDefaultValue (\s a -> s { _taoDefaultValue = a })
taoHighlightEnabled :: Lens' TextArrayOptions (Maybe Bool)
taoHighlightEnabled =
lens _taoHighlightEnabled (\s a -> s { _taoHighlightEnabled = a })
taoReturnEnabled :: Lens' TextArrayOptions (Maybe Bool)
taoReturnEnabled = lens _taoReturnEnabled (\s a -> s { _taoReturnEnabled = a })
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
| Light
| Minimal
| None
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable AlgorithmicStemming
instance FromText AlgorithmicStemming where
parser = takeLowerText >>= \case
"full" -> pure Full
"light" -> pure Light
"minimal" -> pure Minimal
"none" -> pure None
e -> fail $
"Failure parsing AlgorithmicStemming from " ++ show e
instance ToText AlgorithmicStemming where
toText = \case
Full -> "full"
Light -> "light"
Minimal -> "minimal"
None -> "none"
instance ToByteString AlgorithmicStemming
instance ToHeader AlgorithmicStemming
instance ToQuery AlgorithmicStemming
instance FromXML AlgorithmicStemming where
parseXML = parseXMLText "AlgorithmicStemming"
data AnalysisScheme = AnalysisScheme
{ _asAnalysisOptions :: Maybe AnalysisOptions
, _asAnalysisSchemeLanguage :: AnalysisSchemeLanguage
, _asAnalysisSchemeName :: Text
} deriving (Eq, Read, Show)
analysisScheme :: Text
-> AnalysisSchemeLanguage
-> 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 AnalysisSchemeLanguage
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 PartitionInstanceType
, _spDesiredPartitionCount :: Maybe Nat
, _spDesiredReplicationCount :: Maybe Nat
} deriving (Eq, Read, Show)
scalingParameters :: ScalingParameters
scalingParameters = ScalingParameters
{ _spDesiredInstanceType = Nothing
, _spDesiredReplicationCount = Nothing
, _spDesiredPartitionCount = Nothing
}
spDesiredInstanceType :: Lens' ScalingParameters (Maybe PartitionInstanceType)
spDesiredInstanceType =
lens _spDesiredInstanceType (\s a -> s { _spDesiredInstanceType = a })
spDesiredPartitionCount :: Lens' ScalingParameters (Maybe Natural)
spDesiredPartitionCount =
lens _spDesiredPartitionCount (\s a -> s { _spDesiredPartitionCount = a })
. mapping _Nat
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 AlgorithmicStemming
, _aoJapaneseTokenizationDictionary :: Maybe Text
, _aoStemmingDictionary :: Maybe Text
, _aoStopwords :: Maybe Text
, _aoSynonyms :: Maybe Text
} deriving (Eq, Read, Show)
analysisOptions :: AnalysisOptions
analysisOptions = AnalysisOptions
{ _aoSynonyms = Nothing
, _aoStopwords = Nothing
, _aoStemmingDictionary = Nothing
, _aoJapaneseTokenizationDictionary = Nothing
, _aoAlgorithmicStemming = Nothing
}
aoAlgorithmicStemming :: Lens' AnalysisOptions (Maybe AlgorithmicStemming)
aoAlgorithmicStemming =
lens _aoAlgorithmicStemming (\s a -> s { _aoAlgorithmicStemming = a })
aoJapaneseTokenizationDictionary :: Lens' AnalysisOptions (Maybe Text)
aoJapaneseTokenizationDictionary =
lens _aoJapaneseTokenizationDictionary
(\s a -> s { _aoJapaneseTokenizationDictionary = a })
aoStemmingDictionary :: Lens' AnalysisOptions (Maybe Text)
aoStemmingDictionary =
lens _aoStemmingDictionary (\s a -> s { _aoStemmingDictionary = a })
aoStopwords :: Lens' AnalysisOptions (Maybe Text)
aoStopwords = lens _aoStopwords (\s a -> s { _aoStopwords = a })
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, Read, Show)
doubleOptions :: DoubleOptions
doubleOptions = DoubleOptions
{ _do1DefaultValue = Nothing
, _do1SourceField = Nothing
, _do1FacetEnabled = Nothing
, _do1SearchEnabled = Nothing
, _do1ReturnEnabled = Nothing
, _do1SortEnabled = Nothing
}
do1DefaultValue :: Lens' DoubleOptions (Maybe Double)
do1DefaultValue = lens _do1DefaultValue (\s a -> s { _do1DefaultValue = a })
do1FacetEnabled :: Lens' DoubleOptions (Maybe Bool)
do1FacetEnabled = lens _do1FacetEnabled (\s a -> s { _do1FacetEnabled = a })
do1ReturnEnabled :: Lens' DoubleOptions (Maybe Bool)
do1ReturnEnabled = lens _do1ReturnEnabled (\s a -> s { _do1ReturnEnabled = a })
do1SearchEnabled :: Lens' DoubleOptions (Maybe Bool)
do1SearchEnabled = lens _do1SearchEnabled (\s a -> s { _do1SearchEnabled = a })
do1SortEnabled :: Lens' DoubleOptions (Maybe Bool)
do1SortEnabled = lens _do1SortEnabled (\s a -> s { _do1SortEnabled = a })
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, Read, Show)
textOptions :: TextOptions
textOptions = TextOptions
{ _toDefaultValue = Nothing
, _toSourceField = Nothing
, _toReturnEnabled = Nothing
, _toSortEnabled = Nothing
, _toHighlightEnabled = Nothing
, _toAnalysisScheme = Nothing
}
toAnalysisScheme :: Lens' TextOptions (Maybe Text)
toAnalysisScheme = lens _toAnalysisScheme (\s a -> s { _toAnalysisScheme = a })
toDefaultValue :: Lens' TextOptions (Maybe Text)
toDefaultValue = lens _toDefaultValue (\s a -> s { _toDefaultValue = a })
toHighlightEnabled :: Lens' TextOptions (Maybe Bool)
toHighlightEnabled =
lens _toHighlightEnabled (\s a -> s { _toHighlightEnabled = a })
toReturnEnabled :: Lens' TextOptions (Maybe Bool)
toReturnEnabled = lens _toReturnEnabled (\s a -> s { _toReturnEnabled = a })
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, Read, Show)
availabilityOptionsStatus :: Bool
-> OptionStatus
-> AvailabilityOptionsStatus
availabilityOptionsStatus p1 p2 = AvailabilityOptionsStatus
{ _aosOptions = p1
, _aosStatus = p2
}
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, Read, Show)
indexFieldStatus :: IndexField
-> OptionStatus
-> 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, Read, Show)
scalingParametersStatus :: ScalingParameters
-> OptionStatus
-> 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, Read, Show)
analysisSchemeStatus :: AnalysisScheme
-> OptionStatus
-> 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, Read, Show, Monoid)
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, Read, Show)
limits :: Natural
-> Natural
-> 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, Read, Show)
expressionStatus :: Expression
-> OptionStatus
-> ExpressionStatus
expressionStatus p1 p2 = ExpressionStatus
{ _esOptions = p1
, _esStatus = p2
}
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
| IFTDateArray
| IFTDouble
| IFTDoubleArray
| IFTInt
| IFTIntArray
| IFTLatlon
| IFTLiteral
| IFTLiteralArray
| IFTText
| IFTTextArray
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable IndexFieldType
instance FromText IndexFieldType where
parser = takeLowerText >>= \case
"date" -> pure IFTDate
"date-array" -> pure IFTDateArray
"double" -> pure IFTDouble
"double-array" -> pure IFTDoubleArray
"int" -> pure IFTInt
"int-array" -> pure IFTIntArray
"latlon" -> pure IFTLatlon
"literal" -> pure IFTLiteral
"literal-array" -> pure IFTLiteralArray
"text" -> pure IFTText
"text-array" -> pure IFTTextArray
e -> fail $
"Failure parsing IndexFieldType from " ++ show e
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 ToByteString IndexFieldType
instance ToHeader IndexFieldType
instance ToQuery IndexFieldType
instance FromXML IndexFieldType where
parseXML = parseXMLText "IndexFieldType"
data LatLonOptions = LatLonOptions
{ _lloDefaultValue :: Maybe Text
, _lloFacetEnabled :: Maybe Bool
, _lloReturnEnabled :: Maybe Bool
, _lloSearchEnabled :: Maybe Bool
, _lloSortEnabled :: Maybe Bool
, _lloSourceField :: Maybe Text
} deriving (Eq, Ord, Read, Show)
latLonOptions :: LatLonOptions
latLonOptions = LatLonOptions
{ _lloDefaultValue = Nothing
, _lloSourceField = Nothing
, _lloFacetEnabled = Nothing
, _lloSearchEnabled = Nothing
, _lloReturnEnabled = Nothing
, _lloSortEnabled = Nothing
}
lloDefaultValue :: Lens' LatLonOptions (Maybe Text)
lloDefaultValue = lens _lloDefaultValue (\s a -> s { _lloDefaultValue = a })
lloFacetEnabled :: Lens' LatLonOptions (Maybe Bool)
lloFacetEnabled = lens _lloFacetEnabled (\s a -> s { _lloFacetEnabled = a })
lloReturnEnabled :: Lens' LatLonOptions (Maybe Bool)
lloReturnEnabled = lens _lloReturnEnabled (\s a -> s { _lloReturnEnabled = a })
lloSearchEnabled :: Lens' LatLonOptions (Maybe Bool)
lloSearchEnabled = lens _lloSearchEnabled (\s a -> s { _lloSearchEnabled = a })
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, Read, Show)
suggesterStatus :: Suggester
-> OptionStatus
-> 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 :: ISO8601
, _osPendingDeletion :: Maybe Bool
, _osState :: OptionState
, _osUpdateDate :: ISO8601
, _osUpdateVersion :: Maybe Nat
} deriving (Eq, Read, Show)
optionStatus :: UTCTime
-> UTCTime
-> OptionState
-> OptionStatus
optionStatus p1 p2 p3 = OptionStatus
{ _osCreationDate = withIso _Time (const id) p1
, _osUpdateDate = withIso _Time (const id) p2
, _osState = p3
, _osUpdateVersion = Nothing
, _osPendingDeletion = Nothing
}
osCreationDate :: Lens' OptionStatus UTCTime
osCreationDate = lens _osCreationDate (\s a -> s { _osCreationDate = a }) . _Time
osPendingDeletion :: Lens' OptionStatus (Maybe Bool)
osPendingDeletion =
lens _osPendingDeletion (\s a -> s { _osPendingDeletion = a })
osState :: Lens' OptionStatus OptionState
osState = lens _osState (\s a -> s { _osState = a })
osUpdateDate :: Lens' OptionStatus UTCTime
osUpdateDate = lens _osUpdateDate (\s a -> s { _osUpdateDate = a }) . _Time
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, Read, Show)
literalArrayOptions :: LiteralArrayOptions
literalArrayOptions = LiteralArrayOptions
{ _laoDefaultValue = Nothing
, _laoSourceFields = Nothing
, _laoFacetEnabled = Nothing
, _laoSearchEnabled = Nothing
, _laoReturnEnabled = Nothing
}
laoDefaultValue :: Lens' LiteralArrayOptions (Maybe Text)
laoDefaultValue = lens _laoDefaultValue (\s a -> s { _laoDefaultValue = a })
laoFacetEnabled :: Lens' LiteralArrayOptions (Maybe Bool)
laoFacetEnabled = lens _laoFacetEnabled (\s a -> s { _laoFacetEnabled = a })
laoReturnEnabled :: Lens' LiteralArrayOptions (Maybe Bool)
laoReturnEnabled = lens _laoReturnEnabled (\s a -> s { _laoReturnEnabled = a })
laoSearchEnabled :: Lens' LiteralArrayOptions (Maybe Bool)
laoSearchEnabled = lens _laoSearchEnabled (\s a -> s { _laoSearchEnabled = a })
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, Read, Show)
intArrayOptions :: IntArrayOptions
intArrayOptions = IntArrayOptions
{ _iaoDefaultValue = Nothing
, _iaoSourceFields = Nothing
, _iaoFacetEnabled = Nothing
, _iaoSearchEnabled = Nothing
, _iaoReturnEnabled = Nothing
}
iaoDefaultValue :: Lens' IntArrayOptions (Maybe Integer)
iaoDefaultValue = lens _iaoDefaultValue (\s a -> s { _iaoDefaultValue = a })
iaoFacetEnabled :: Lens' IntArrayOptions (Maybe Bool)
iaoFacetEnabled = lens _iaoFacetEnabled (\s a -> s { _iaoFacetEnabled = a })
iaoReturnEnabled :: Lens' IntArrayOptions (Maybe Bool)
iaoReturnEnabled = lens _iaoReturnEnabled (\s a -> s { _iaoReturnEnabled = a })
iaoSearchEnabled :: Lens' IntArrayOptions (Maybe Bool)
iaoSearchEnabled = lens _iaoSearchEnabled (\s a -> s { _iaoSearchEnabled = a })
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, Read, Show)
expression :: Text
-> Text
-> 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
| SFMLow
| SFMNone
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable SuggesterFuzzyMatching
instance FromText SuggesterFuzzyMatching where
parser = takeLowerText >>= \case
"high" -> pure SFMHigh
"low" -> pure SFMLow
"none" -> pure SFMNone
e -> fail $
"Failure parsing SuggesterFuzzyMatching from " ++ show e
instance ToText SuggesterFuzzyMatching where
toText = \case
SFMHigh -> "high"
SFMLow -> "low"
SFMNone -> "none"
instance ToByteString SuggesterFuzzyMatching
instance ToHeader SuggesterFuzzyMatching
instance ToQuery SuggesterFuzzyMatching
instance FromXML SuggesterFuzzyMatching where
parseXML = parseXMLText "SuggesterFuzzyMatching"
data DateArrayOptions = DateArrayOptions
{ _dao1DefaultValue :: Maybe Text
, _dao1FacetEnabled :: Maybe Bool
, _dao1ReturnEnabled :: Maybe Bool
, _dao1SearchEnabled :: Maybe Bool
, _dao1SourceFields :: Maybe Text
} deriving (Eq, Ord, Read, Show)
dateArrayOptions :: DateArrayOptions
dateArrayOptions = DateArrayOptions
{ _dao1DefaultValue = Nothing
, _dao1SourceFields = Nothing
, _dao1FacetEnabled = Nothing
, _dao1SearchEnabled = Nothing
, _dao1ReturnEnabled = Nothing
}
dao1DefaultValue :: Lens' DateArrayOptions (Maybe Text)
dao1DefaultValue = lens _dao1DefaultValue (\s a -> s { _dao1DefaultValue = a })
dao1FacetEnabled :: Lens' DateArrayOptions (Maybe Bool)
dao1FacetEnabled = lens _dao1FacetEnabled (\s a -> s { _dao1FacetEnabled = a })
dao1ReturnEnabled :: Lens' DateArrayOptions (Maybe Bool)
dao1ReturnEnabled =
lens _dao1ReturnEnabled (\s a -> s { _dao1ReturnEnabled = a })
dao1SearchEnabled :: Lens' DateArrayOptions (Maybe Bool)
dao1SearchEnabled =
lens _dao1SearchEnabled (\s a -> s { _dao1SearchEnabled = a })
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
| Bg
| Ca
| Cs
| Da
| De
| El
| En
| Es
| Eu
| Fa
| Fi
| Fr
| Ga
| Gl
| He
| Hi
| Hu
| Hy
| Id
| It
| Ja
| Ko
| Lv
| Mul
| Nl
| No
| Pt
| Ro
| Ru
| Sv
| Th
| Tr
| ZhHans
| ZhHant
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable AnalysisSchemeLanguage
instance FromText AnalysisSchemeLanguage where
parser = takeLowerText >>= \case
"ar" -> pure Ar
"bg" -> pure Bg
"ca" -> pure Ca
"cs" -> pure Cs
"da" -> pure Da
"de" -> pure De
"el" -> pure El
"en" -> pure En
"es" -> pure Es
"eu" -> pure Eu
"fa" -> pure Fa
"fi" -> pure Fi
"fr" -> pure Fr
"ga" -> pure Ga
"gl" -> pure Gl
"he" -> pure He
"hi" -> pure Hi
"hu" -> pure Hu
"hy" -> pure Hy
"id" -> pure Id
"it" -> pure It
"ja" -> pure Ja
"ko" -> pure Ko
"lv" -> pure Lv
"mul" -> pure Mul
"nl" -> pure Nl
"no" -> pure No
"pt" -> pure Pt
"ro" -> pure Ro
"ru" -> pure Ru
"sv" -> pure Sv
"th" -> pure Th
"tr" -> pure Tr
"zh-hans" -> pure ZhHans
"zh-hant" -> pure ZhHant
e -> fail $
"Failure parsing AnalysisSchemeLanguage from " ++ show e
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 ToByteString AnalysisSchemeLanguage
instance ToHeader AnalysisSchemeLanguage
instance ToQuery AnalysisSchemeLanguage
instance FromXML AnalysisSchemeLanguage where
parseXML = parseXMLText "AnalysisSchemeLanguage"
data PartitionInstanceType
= SearchM1Large
| SearchM1Small
| SearchM22xlarge
| SearchM2Xlarge
| SearchM32xlarge
| SearchM3Large
| SearchM3Medium
| SearchM3Xlarge
deriving (Eq, Ord, Read, Show, Generic, Enum)
instance Hashable PartitionInstanceType
instance FromText PartitionInstanceType where
parser = takeLowerText >>= \case
"search.m1.large" -> pure SearchM1Large
"search.m1.small" -> pure SearchM1Small
"search.m2.2xlarge" -> pure SearchM22xlarge
"search.m2.xlarge" -> pure SearchM2Xlarge
"search.m3.2xlarge" -> pure SearchM32xlarge
"search.m3.large" -> pure SearchM3Large
"search.m3.medium" -> pure SearchM3Medium
"search.m3.xlarge" -> pure SearchM3Xlarge
e -> fail $
"Failure parsing PartitionInstanceType from " ++ show e
instance ToText PartitionInstanceType where
toText = \case
SearchM1Large -> "search.m1.large"
SearchM1Small -> "search.m1.small"
SearchM22xlarge -> "search.m2.2xlarge"
SearchM2Xlarge -> "search.m2.xlarge"
SearchM32xlarge -> "search.m3.2xlarge"
SearchM3Large -> "search.m3.large"
SearchM3Medium -> "search.m3.medium"
SearchM3Xlarge -> "search.m3.xlarge"
instance ToByteString PartitionInstanceType
instance ToHeader PartitionInstanceType
instance ToQuery PartitionInstanceType
instance FromXML PartitionInstanceType where
parseXML = parseXMLText "PartitionInstanceType"
data Suggester = Suggester
{ _sDocumentSuggesterOptions :: DocumentSuggesterOptions
, _sSuggesterName :: Text
} deriving (Eq, Read, Show)
suggester :: Text
-> DocumentSuggesterOptions
-> 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, Read, Show)
intOptions :: IntOptions
intOptions = IntOptions
{ _ioDefaultValue = Nothing
, _ioSourceField = Nothing
, _ioFacetEnabled = Nothing
, _ioSearchEnabled = Nothing
, _ioReturnEnabled = Nothing
, _ioSortEnabled = Nothing
}
ioDefaultValue :: Lens' IntOptions (Maybe Integer)
ioDefaultValue = lens _ioDefaultValue (\s a -> s { _ioDefaultValue = a })
ioFacetEnabled :: Lens' IntOptions (Maybe Bool)
ioFacetEnabled = lens _ioFacetEnabled (\s a -> s { _ioFacetEnabled = a })
ioReturnEnabled :: Lens' IntOptions (Maybe Bool)
ioReturnEnabled = lens _ioReturnEnabled (\s a -> s { _ioReturnEnabled = a })
ioSearchEnabled :: Lens' IntOptions (Maybe Bool)
ioSearchEnabled = lens _ioSearchEnabled (\s a -> s { _ioSearchEnabled = a })
ioSortEnabled :: Lens' IntOptions (Maybe Bool)
ioSortEnabled = lens _ioSortEnabled (\s a -> s { _ioSortEnabled = a })
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, Read, Show)
literalOptions :: LiteralOptions
literalOptions = LiteralOptions
{ _loDefaultValue = Nothing
, _loSourceField = Nothing
, _loFacetEnabled = Nothing
, _loSearchEnabled = Nothing
, _loReturnEnabled = Nothing
, _loSortEnabled = Nothing
}
loDefaultValue :: Lens' LiteralOptions (Maybe Text)
loDefaultValue = lens _loDefaultValue (\s a -> s { _loDefaultValue = a })
loFacetEnabled :: Lens' LiteralOptions (Maybe Bool)
loFacetEnabled = lens _loFacetEnabled (\s a -> s { _loFacetEnabled = a })
loReturnEnabled :: Lens' LiteralOptions (Maybe Bool)
loReturnEnabled = lens _loReturnEnabled (\s a -> s { _loReturnEnabled = a })
loSearchEnabled :: Lens' LiteralOptions (Maybe Bool)
loSearchEnabled = lens _loSearchEnabled (\s a -> s { _loSearchEnabled = a })
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, Read, Show)
accessPoliciesStatus :: Text
-> OptionStatus
-> 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
]