{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}
module Network.AWS.AppSync.ListTypes
(
listTypes
, ListTypes
, ltNextToken
, ltMaxResults
, ltApiId
, ltFormat
, listTypesResponse
, ListTypesResponse
, ltrsTypes
, ltrsNextToken
, ltrsResponseStatus
) where
import Network.AWS.AppSync.Types
import Network.AWS.AppSync.Types.Product
import Network.AWS.Lens
import Network.AWS.Prelude
import Network.AWS.Request
import Network.AWS.Response
data ListTypes = ListTypes'
{ _ltNextToken :: !(Maybe Text)
, _ltMaxResults :: !(Maybe Nat)
, _ltApiId :: !Text
, _ltFormat :: !TypeDefinitionFormat
} deriving (Eq, Read, Show, Data, Typeable, Generic)
listTypes
:: Text
-> TypeDefinitionFormat
-> ListTypes
listTypes pApiId_ pFormat_ =
ListTypes'
{ _ltNextToken = Nothing
, _ltMaxResults = Nothing
, _ltApiId = pApiId_
, _ltFormat = pFormat_
}
ltNextToken :: Lens' ListTypes (Maybe Text)
ltNextToken = lens _ltNextToken (\ s a -> s{_ltNextToken = a})
ltMaxResults :: Lens' ListTypes (Maybe Natural)
ltMaxResults = lens _ltMaxResults (\ s a -> s{_ltMaxResults = a}) . mapping _Nat
ltApiId :: Lens' ListTypes Text
ltApiId = lens _ltApiId (\ s a -> s{_ltApiId = a})
ltFormat :: Lens' ListTypes TypeDefinitionFormat
ltFormat = lens _ltFormat (\ s a -> s{_ltFormat = a})
instance AWSRequest ListTypes where
type Rs ListTypes = ListTypesResponse
request = get appSync
response
= receiveJSON
(\ s h x ->
ListTypesResponse' <$>
(x .?> "types" .!@ mempty) <*> (x .?> "nextToken")
<*> (pure (fromEnum s)))
instance Hashable ListTypes where
instance NFData ListTypes where
instance ToHeaders ListTypes where
toHeaders
= const
(mconcat
["Content-Type" =#
("application/x-amz-json-1.1" :: ByteString)])
instance ToPath ListTypes where
toPath ListTypes'{..}
= mconcat ["/v1/apis/", toBS _ltApiId, "/types"]
instance ToQuery ListTypes where
toQuery ListTypes'{..}
= mconcat
["nextToken" =: _ltNextToken,
"maxResults" =: _ltMaxResults, "format" =: _ltFormat]
data ListTypesResponse = ListTypesResponse'
{ _ltrsTypes :: !(Maybe [Type])
, _ltrsNextToken :: !(Maybe Text)
, _ltrsResponseStatus :: !Int
} deriving (Eq, Read, Show, Data, Typeable, Generic)
listTypesResponse
:: Int
-> ListTypesResponse
listTypesResponse pResponseStatus_ =
ListTypesResponse'
{ _ltrsTypes = Nothing
, _ltrsNextToken = Nothing
, _ltrsResponseStatus = pResponseStatus_
}
ltrsTypes :: Lens' ListTypesResponse [Type]
ltrsTypes = lens _ltrsTypes (\ s a -> s{_ltrsTypes = a}) . _Default . _Coerce
ltrsNextToken :: Lens' ListTypesResponse (Maybe Text)
ltrsNextToken = lens _ltrsNextToken (\ s a -> s{_ltrsNextToken = a})
ltrsResponseStatus :: Lens' ListTypesResponse Int
ltrsResponseStatus = lens _ltrsResponseStatus (\ s a -> s{_ltrsResponseStatus = a})
instance NFData ListTypesResponse where