{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module Network.AWS.StorageGateway.Types.Product where
import Network.AWS.Lens
import Network.AWS.Prelude
import Network.AWS.StorageGateway.Types.Sum
data CachediSCSIVolume = CachediSCSIVolume'
{ _cscsivVolumeiSCSIAttributes :: !(Maybe VolumeiSCSIAttributes)
, _cscsivVolumeStatus :: !(Maybe Text)
, _cscsivSourceSnapshotId :: !(Maybe Text)
, _cscsivVolumeARN :: !(Maybe Text)
, _cscsivVolumeProgress :: !(Maybe Double)
, _cscsivVolumeSizeInBytes :: !(Maybe Integer)
, _cscsivVolumeUsedInBytes :: !(Maybe Integer)
, _cscsivCreatedDate :: !(Maybe POSIX)
, _cscsivVolumeId :: !(Maybe Text)
, _cscsivVolumeType :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
cachediSCSIVolume
:: CachediSCSIVolume
cachediSCSIVolume =
CachediSCSIVolume'
{ _cscsivVolumeiSCSIAttributes = Nothing
, _cscsivVolumeStatus = Nothing
, _cscsivSourceSnapshotId = Nothing
, _cscsivVolumeARN = Nothing
, _cscsivVolumeProgress = Nothing
, _cscsivVolumeSizeInBytes = Nothing
, _cscsivVolumeUsedInBytes = Nothing
, _cscsivCreatedDate = Nothing
, _cscsivVolumeId = Nothing
, _cscsivVolumeType = Nothing
}
cscsivVolumeiSCSIAttributes :: Lens' CachediSCSIVolume (Maybe VolumeiSCSIAttributes)
cscsivVolumeiSCSIAttributes = lens _cscsivVolumeiSCSIAttributes (\ s a -> s{_cscsivVolumeiSCSIAttributes = a})
cscsivVolumeStatus :: Lens' CachediSCSIVolume (Maybe Text)
cscsivVolumeStatus = lens _cscsivVolumeStatus (\ s a -> s{_cscsivVolumeStatus = a})
cscsivSourceSnapshotId :: Lens' CachediSCSIVolume (Maybe Text)
cscsivSourceSnapshotId = lens _cscsivSourceSnapshotId (\ s a -> s{_cscsivSourceSnapshotId = a})
cscsivVolumeARN :: Lens' CachediSCSIVolume (Maybe Text)
cscsivVolumeARN = lens _cscsivVolumeARN (\ s a -> s{_cscsivVolumeARN = a})
cscsivVolumeProgress :: Lens' CachediSCSIVolume (Maybe Double)
cscsivVolumeProgress = lens _cscsivVolumeProgress (\ s a -> s{_cscsivVolumeProgress = a})
cscsivVolumeSizeInBytes :: Lens' CachediSCSIVolume (Maybe Integer)
cscsivVolumeSizeInBytes = lens _cscsivVolumeSizeInBytes (\ s a -> s{_cscsivVolumeSizeInBytes = a})
cscsivVolumeUsedInBytes :: Lens' CachediSCSIVolume (Maybe Integer)
cscsivVolumeUsedInBytes = lens _cscsivVolumeUsedInBytes (\ s a -> s{_cscsivVolumeUsedInBytes = a})
cscsivCreatedDate :: Lens' CachediSCSIVolume (Maybe UTCTime)
cscsivCreatedDate = lens _cscsivCreatedDate (\ s a -> s{_cscsivCreatedDate = a}) . mapping _Time
cscsivVolumeId :: Lens' CachediSCSIVolume (Maybe Text)
cscsivVolumeId = lens _cscsivVolumeId (\ s a -> s{_cscsivVolumeId = a})
cscsivVolumeType :: Lens' CachediSCSIVolume (Maybe Text)
cscsivVolumeType = lens _cscsivVolumeType (\ s a -> s{_cscsivVolumeType = a})
instance FromJSON CachediSCSIVolume where
parseJSON
= withObject "CachediSCSIVolume"
(\ x ->
CachediSCSIVolume' <$>
(x .:? "VolumeiSCSIAttributes") <*>
(x .:? "VolumeStatus")
<*> (x .:? "SourceSnapshotId")
<*> (x .:? "VolumeARN")
<*> (x .:? "VolumeProgress")
<*> (x .:? "VolumeSizeInBytes")
<*> (x .:? "VolumeUsedInBytes")
<*> (x .:? "CreatedDate")
<*> (x .:? "VolumeId")
<*> (x .:? "VolumeType"))
instance Hashable CachediSCSIVolume where
instance NFData CachediSCSIVolume where
data ChapInfo = ChapInfo'
{ _ciTargetARN :: !(Maybe Text)
, _ciSecretToAuthenticateInitiator :: !(Maybe Text)
, _ciInitiatorName :: !(Maybe Text)
, _ciSecretToAuthenticateTarget :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
chapInfo
:: ChapInfo
chapInfo =
ChapInfo'
{ _ciTargetARN = Nothing
, _ciSecretToAuthenticateInitiator = Nothing
, _ciInitiatorName = Nothing
, _ciSecretToAuthenticateTarget = Nothing
}
ciTargetARN :: Lens' ChapInfo (Maybe Text)
ciTargetARN = lens _ciTargetARN (\ s a -> s{_ciTargetARN = a})
ciSecretToAuthenticateInitiator :: Lens' ChapInfo (Maybe Text)
ciSecretToAuthenticateInitiator = lens _ciSecretToAuthenticateInitiator (\ s a -> s{_ciSecretToAuthenticateInitiator = a})
ciInitiatorName :: Lens' ChapInfo (Maybe Text)
ciInitiatorName = lens _ciInitiatorName (\ s a -> s{_ciInitiatorName = a})
ciSecretToAuthenticateTarget :: Lens' ChapInfo (Maybe Text)
ciSecretToAuthenticateTarget = lens _ciSecretToAuthenticateTarget (\ s a -> s{_ciSecretToAuthenticateTarget = a})
instance FromJSON ChapInfo where
parseJSON
= withObject "ChapInfo"
(\ x ->
ChapInfo' <$>
(x .:? "TargetARN") <*>
(x .:? "SecretToAuthenticateInitiator")
<*> (x .:? "InitiatorName")
<*> (x .:? "SecretToAuthenticateTarget"))
instance Hashable ChapInfo where
instance NFData ChapInfo where
data DeviceiSCSIAttributes = DeviceiSCSIAttributes'
{ _dscsiaTargetARN :: !(Maybe Text)
, _dscsiaChapEnabled :: !(Maybe Bool)
, _dscsiaNetworkInterfaceId :: !(Maybe Text)
, _dscsiaNetworkInterfacePort :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
deviceiSCSIAttributes
:: DeviceiSCSIAttributes
deviceiSCSIAttributes =
DeviceiSCSIAttributes'
{ _dscsiaTargetARN = Nothing
, _dscsiaChapEnabled = Nothing
, _dscsiaNetworkInterfaceId = Nothing
, _dscsiaNetworkInterfacePort = Nothing
}
dscsiaTargetARN :: Lens' DeviceiSCSIAttributes (Maybe Text)
dscsiaTargetARN = lens _dscsiaTargetARN (\ s a -> s{_dscsiaTargetARN = a})
dscsiaChapEnabled :: Lens' DeviceiSCSIAttributes (Maybe Bool)
dscsiaChapEnabled = lens _dscsiaChapEnabled (\ s a -> s{_dscsiaChapEnabled = a})
dscsiaNetworkInterfaceId :: Lens' DeviceiSCSIAttributes (Maybe Text)
dscsiaNetworkInterfaceId = lens _dscsiaNetworkInterfaceId (\ s a -> s{_dscsiaNetworkInterfaceId = a})
dscsiaNetworkInterfacePort :: Lens' DeviceiSCSIAttributes (Maybe Int)
dscsiaNetworkInterfacePort = lens _dscsiaNetworkInterfacePort (\ s a -> s{_dscsiaNetworkInterfacePort = a})
instance FromJSON DeviceiSCSIAttributes where
parseJSON
= withObject "DeviceiSCSIAttributes"
(\ x ->
DeviceiSCSIAttributes' <$>
(x .:? "TargetARN") <*> (x .:? "ChapEnabled") <*>
(x .:? "NetworkInterfaceId")
<*> (x .:? "NetworkInterfacePort"))
instance Hashable DeviceiSCSIAttributes where
instance NFData DeviceiSCSIAttributes where
data Disk = Disk'
{ _dDiskAllocationResource :: !(Maybe Text)
, _dDiskAllocationType :: !(Maybe Text)
, _dDiskNode :: !(Maybe Text)
, _dDiskPath :: !(Maybe Text)
, _dDiskSizeInBytes :: !(Maybe Integer)
, _dDiskStatus :: !(Maybe Text)
, _dDiskId :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
disk
:: Disk
disk =
Disk'
{ _dDiskAllocationResource = Nothing
, _dDiskAllocationType = Nothing
, _dDiskNode = Nothing
, _dDiskPath = Nothing
, _dDiskSizeInBytes = Nothing
, _dDiskStatus = Nothing
, _dDiskId = Nothing
}
dDiskAllocationResource :: Lens' Disk (Maybe Text)
dDiskAllocationResource = lens _dDiskAllocationResource (\ s a -> s{_dDiskAllocationResource = a})
dDiskAllocationType :: Lens' Disk (Maybe Text)
dDiskAllocationType = lens _dDiskAllocationType (\ s a -> s{_dDiskAllocationType = a})
dDiskNode :: Lens' Disk (Maybe Text)
dDiskNode = lens _dDiskNode (\ s a -> s{_dDiskNode = a})
dDiskPath :: Lens' Disk (Maybe Text)
dDiskPath = lens _dDiskPath (\ s a -> s{_dDiskPath = a})
dDiskSizeInBytes :: Lens' Disk (Maybe Integer)
dDiskSizeInBytes = lens _dDiskSizeInBytes (\ s a -> s{_dDiskSizeInBytes = a})
dDiskStatus :: Lens' Disk (Maybe Text)
dDiskStatus = lens _dDiskStatus (\ s a -> s{_dDiskStatus = a})
dDiskId :: Lens' Disk (Maybe Text)
dDiskId = lens _dDiskId (\ s a -> s{_dDiskId = a})
instance FromJSON Disk where
parseJSON
= withObject "Disk"
(\ x ->
Disk' <$>
(x .:? "DiskAllocationResource") <*>
(x .:? "DiskAllocationType")
<*> (x .:? "DiskNode")
<*> (x .:? "DiskPath")
<*> (x .:? "DiskSizeInBytes")
<*> (x .:? "DiskStatus")
<*> (x .:? "DiskId"))
instance Hashable Disk where
instance NFData Disk where
data FileShareInfo = FileShareInfo'
{ _fsiFileShareStatus :: !(Maybe Text)
, _fsiGatewayARN :: !(Maybe Text)
, _fsiFileShareId :: !(Maybe Text)
, _fsiFileShareARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
fileShareInfo
:: FileShareInfo
fileShareInfo =
FileShareInfo'
{ _fsiFileShareStatus = Nothing
, _fsiGatewayARN = Nothing
, _fsiFileShareId = Nothing
, _fsiFileShareARN = Nothing
}
fsiFileShareStatus :: Lens' FileShareInfo (Maybe Text)
fsiFileShareStatus = lens _fsiFileShareStatus (\ s a -> s{_fsiFileShareStatus = a})
fsiGatewayARN :: Lens' FileShareInfo (Maybe Text)
fsiGatewayARN = lens _fsiGatewayARN (\ s a -> s{_fsiGatewayARN = a})
fsiFileShareId :: Lens' FileShareInfo (Maybe Text)
fsiFileShareId = lens _fsiFileShareId (\ s a -> s{_fsiFileShareId = a})
fsiFileShareARN :: Lens' FileShareInfo (Maybe Text)
fsiFileShareARN = lens _fsiFileShareARN (\ s a -> s{_fsiFileShareARN = a})
instance FromJSON FileShareInfo where
parseJSON
= withObject "FileShareInfo"
(\ x ->
FileShareInfo' <$>
(x .:? "FileShareStatus") <*> (x .:? "GatewayARN")
<*> (x .:? "FileShareId")
<*> (x .:? "FileShareARN"))
instance Hashable FileShareInfo where
instance NFData FileShareInfo where
data GatewayInfo = GatewayInfo'
{ _giGatewayARN :: !(Maybe Text)
, _giGatewayOperationalState :: !(Maybe Text)
, _giGatewayName :: !(Maybe Text)
, _giGatewayId :: !(Maybe Text)
, _giGatewayType :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
gatewayInfo
:: GatewayInfo
gatewayInfo =
GatewayInfo'
{ _giGatewayARN = Nothing
, _giGatewayOperationalState = Nothing
, _giGatewayName = Nothing
, _giGatewayId = Nothing
, _giGatewayType = Nothing
}
giGatewayARN :: Lens' GatewayInfo (Maybe Text)
giGatewayARN = lens _giGatewayARN (\ s a -> s{_giGatewayARN = a})
giGatewayOperationalState :: Lens' GatewayInfo (Maybe Text)
giGatewayOperationalState = lens _giGatewayOperationalState (\ s a -> s{_giGatewayOperationalState = a})
giGatewayName :: Lens' GatewayInfo (Maybe Text)
giGatewayName = lens _giGatewayName (\ s a -> s{_giGatewayName = a})
giGatewayId :: Lens' GatewayInfo (Maybe Text)
giGatewayId = lens _giGatewayId (\ s a -> s{_giGatewayId = a})
giGatewayType :: Lens' GatewayInfo (Maybe Text)
giGatewayType = lens _giGatewayType (\ s a -> s{_giGatewayType = a})
instance FromJSON GatewayInfo where
parseJSON
= withObject "GatewayInfo"
(\ x ->
GatewayInfo' <$>
(x .:? "GatewayARN") <*>
(x .:? "GatewayOperationalState")
<*> (x .:? "GatewayName")
<*> (x .:? "GatewayId")
<*> (x .:? "GatewayType"))
instance Hashable GatewayInfo where
instance NFData GatewayInfo where
data NFSFileShareDefaults = NFSFileShareDefaults'
{ _nfsfsdFileMode :: !(Maybe Text)
, _nfsfsdOwnerId :: !(Maybe Nat)
, _nfsfsdDirectoryMode :: !(Maybe Text)
, _nfsfsdGroupId :: !(Maybe Nat)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
nFSFileShareDefaults
:: NFSFileShareDefaults
nFSFileShareDefaults =
NFSFileShareDefaults'
{ _nfsfsdFileMode = Nothing
, _nfsfsdOwnerId = Nothing
, _nfsfsdDirectoryMode = Nothing
, _nfsfsdGroupId = Nothing
}
nfsfsdFileMode :: Lens' NFSFileShareDefaults (Maybe Text)
nfsfsdFileMode = lens _nfsfsdFileMode (\ s a -> s{_nfsfsdFileMode = a})
nfsfsdOwnerId :: Lens' NFSFileShareDefaults (Maybe Natural)
nfsfsdOwnerId = lens _nfsfsdOwnerId (\ s a -> s{_nfsfsdOwnerId = a}) . mapping _Nat
nfsfsdDirectoryMode :: Lens' NFSFileShareDefaults (Maybe Text)
nfsfsdDirectoryMode = lens _nfsfsdDirectoryMode (\ s a -> s{_nfsfsdDirectoryMode = a})
nfsfsdGroupId :: Lens' NFSFileShareDefaults (Maybe Natural)
nfsfsdGroupId = lens _nfsfsdGroupId (\ s a -> s{_nfsfsdGroupId = a}) . mapping _Nat
instance FromJSON NFSFileShareDefaults where
parseJSON
= withObject "NFSFileShareDefaults"
(\ x ->
NFSFileShareDefaults' <$>
(x .:? "FileMode") <*> (x .:? "OwnerId") <*>
(x .:? "DirectoryMode")
<*> (x .:? "GroupId"))
instance Hashable NFSFileShareDefaults where
instance NFData NFSFileShareDefaults where
instance ToJSON NFSFileShareDefaults where
toJSON NFSFileShareDefaults'{..}
= object
(catMaybes
[("FileMode" .=) <$> _nfsfsdFileMode,
("OwnerId" .=) <$> _nfsfsdOwnerId,
("DirectoryMode" .=) <$> _nfsfsdDirectoryMode,
("GroupId" .=) <$> _nfsfsdGroupId])
data NFSFileShareInfo = NFSFileShareInfo'
{ _nfsfsiFileShareStatus :: !(Maybe Text)
, _nfsfsiKMSKey :: !(Maybe Text)
, _nfsfsiGatewayARN :: !(Maybe Text)
, _nfsfsiPath :: !(Maybe Text)
, _nfsfsiObjectACL :: !(Maybe ObjectACL)
, _nfsfsiKMSEncrypted :: !(Maybe Bool)
, _nfsfsiFileShareId :: !(Maybe Text)
, _nfsfsiFileShareARN :: !(Maybe Text)
, _nfsfsiDefaultStorageClass :: !(Maybe Text)
, _nfsfsiRole :: !(Maybe Text)
, _nfsfsiSquash :: !(Maybe Text)
, _nfsfsiRequesterPays :: !(Maybe Bool)
, _nfsfsiNFSFileShareDefaults :: !(Maybe NFSFileShareDefaults)
, _nfsfsiLocationARN :: !(Maybe Text)
, _nfsfsiClientList :: !(Maybe (List1 Text))
, _nfsfsiGuessMIMETypeEnabled :: !(Maybe Bool)
, _nfsfsiReadOnly :: !(Maybe Bool)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
nFSFileShareInfo
:: NFSFileShareInfo
nFSFileShareInfo =
NFSFileShareInfo'
{ _nfsfsiFileShareStatus = Nothing
, _nfsfsiKMSKey = Nothing
, _nfsfsiGatewayARN = Nothing
, _nfsfsiPath = Nothing
, _nfsfsiObjectACL = Nothing
, _nfsfsiKMSEncrypted = Nothing
, _nfsfsiFileShareId = Nothing
, _nfsfsiFileShareARN = Nothing
, _nfsfsiDefaultStorageClass = Nothing
, _nfsfsiRole = Nothing
, _nfsfsiSquash = Nothing
, _nfsfsiRequesterPays = Nothing
, _nfsfsiNFSFileShareDefaults = Nothing
, _nfsfsiLocationARN = Nothing
, _nfsfsiClientList = Nothing
, _nfsfsiGuessMIMETypeEnabled = Nothing
, _nfsfsiReadOnly = Nothing
}
nfsfsiFileShareStatus :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiFileShareStatus = lens _nfsfsiFileShareStatus (\ s a -> s{_nfsfsiFileShareStatus = a})
nfsfsiKMSKey :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiKMSKey = lens _nfsfsiKMSKey (\ s a -> s{_nfsfsiKMSKey = a})
nfsfsiGatewayARN :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiGatewayARN = lens _nfsfsiGatewayARN (\ s a -> s{_nfsfsiGatewayARN = a})
nfsfsiPath :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiPath = lens _nfsfsiPath (\ s a -> s{_nfsfsiPath = a})
nfsfsiObjectACL :: Lens' NFSFileShareInfo (Maybe ObjectACL)
nfsfsiObjectACL = lens _nfsfsiObjectACL (\ s a -> s{_nfsfsiObjectACL = a})
nfsfsiKMSEncrypted :: Lens' NFSFileShareInfo (Maybe Bool)
nfsfsiKMSEncrypted = lens _nfsfsiKMSEncrypted (\ s a -> s{_nfsfsiKMSEncrypted = a})
nfsfsiFileShareId :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiFileShareId = lens _nfsfsiFileShareId (\ s a -> s{_nfsfsiFileShareId = a})
nfsfsiFileShareARN :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiFileShareARN = lens _nfsfsiFileShareARN (\ s a -> s{_nfsfsiFileShareARN = a})
nfsfsiDefaultStorageClass :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiDefaultStorageClass = lens _nfsfsiDefaultStorageClass (\ s a -> s{_nfsfsiDefaultStorageClass = a})
nfsfsiRole :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiRole = lens _nfsfsiRole (\ s a -> s{_nfsfsiRole = a})
nfsfsiSquash :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiSquash = lens _nfsfsiSquash (\ s a -> s{_nfsfsiSquash = a})
nfsfsiRequesterPays :: Lens' NFSFileShareInfo (Maybe Bool)
nfsfsiRequesterPays = lens _nfsfsiRequesterPays (\ s a -> s{_nfsfsiRequesterPays = a})
nfsfsiNFSFileShareDefaults :: Lens' NFSFileShareInfo (Maybe NFSFileShareDefaults)
nfsfsiNFSFileShareDefaults = lens _nfsfsiNFSFileShareDefaults (\ s a -> s{_nfsfsiNFSFileShareDefaults = a})
nfsfsiLocationARN :: Lens' NFSFileShareInfo (Maybe Text)
nfsfsiLocationARN = lens _nfsfsiLocationARN (\ s a -> s{_nfsfsiLocationARN = a})
nfsfsiClientList :: Lens' NFSFileShareInfo (Maybe (NonEmpty Text))
nfsfsiClientList = lens _nfsfsiClientList (\ s a -> s{_nfsfsiClientList = a}) . mapping _List1
nfsfsiGuessMIMETypeEnabled :: Lens' NFSFileShareInfo (Maybe Bool)
nfsfsiGuessMIMETypeEnabled = lens _nfsfsiGuessMIMETypeEnabled (\ s a -> s{_nfsfsiGuessMIMETypeEnabled = a})
nfsfsiReadOnly :: Lens' NFSFileShareInfo (Maybe Bool)
nfsfsiReadOnly = lens _nfsfsiReadOnly (\ s a -> s{_nfsfsiReadOnly = a})
instance FromJSON NFSFileShareInfo where
parseJSON
= withObject "NFSFileShareInfo"
(\ x ->
NFSFileShareInfo' <$>
(x .:? "FileShareStatus") <*> (x .:? "KMSKey") <*>
(x .:? "GatewayARN")
<*> (x .:? "Path")
<*> (x .:? "ObjectACL")
<*> (x .:? "KMSEncrypted")
<*> (x .:? "FileShareId")
<*> (x .:? "FileShareARN")
<*> (x .:? "DefaultStorageClass")
<*> (x .:? "Role")
<*> (x .:? "Squash")
<*> (x .:? "RequesterPays")
<*> (x .:? "NFSFileShareDefaults")
<*> (x .:? "LocationARN")
<*> (x .:? "ClientList")
<*> (x .:? "GuessMIMETypeEnabled")
<*> (x .:? "ReadOnly"))
instance Hashable NFSFileShareInfo where
instance NFData NFSFileShareInfo where
data NetworkInterface = NetworkInterface'
{ _niIPv6Address :: !(Maybe Text)
, _niMACAddress :: !(Maybe Text)
, _niIPv4Address :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
networkInterface
:: NetworkInterface
networkInterface =
NetworkInterface'
{ _niIPv6Address = Nothing
, _niMACAddress = Nothing
, _niIPv4Address = Nothing
}
niIPv6Address :: Lens' NetworkInterface (Maybe Text)
niIPv6Address = lens _niIPv6Address (\ s a -> s{_niIPv6Address = a})
niMACAddress :: Lens' NetworkInterface (Maybe Text)
niMACAddress = lens _niMACAddress (\ s a -> s{_niMACAddress = a})
niIPv4Address :: Lens' NetworkInterface (Maybe Text)
niIPv4Address = lens _niIPv4Address (\ s a -> s{_niIPv4Address = a})
instance FromJSON NetworkInterface where
parseJSON
= withObject "NetworkInterface"
(\ x ->
NetworkInterface' <$>
(x .:? "Ipv6Address") <*> (x .:? "MacAddress") <*>
(x .:? "Ipv4Address"))
instance Hashable NetworkInterface where
instance NFData NetworkInterface where
data StorediSCSIVolume = StorediSCSIVolume'
{ _sscsivVolumeiSCSIAttributes :: !(Maybe VolumeiSCSIAttributes)
, _sscsivVolumeStatus :: !(Maybe Text)
, _sscsivSourceSnapshotId :: !(Maybe Text)
, _sscsivPreservedExistingData :: !(Maybe Bool)
, _sscsivVolumeARN :: !(Maybe Text)
, _sscsivVolumeProgress :: !(Maybe Double)
, _sscsivVolumeSizeInBytes :: !(Maybe Integer)
, _sscsivVolumeUsedInBytes :: !(Maybe Integer)
, _sscsivCreatedDate :: !(Maybe POSIX)
, _sscsivVolumeId :: !(Maybe Text)
, _sscsivVolumeDiskId :: !(Maybe Text)
, _sscsivVolumeType :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
storediSCSIVolume
:: StorediSCSIVolume
storediSCSIVolume =
StorediSCSIVolume'
{ _sscsivVolumeiSCSIAttributes = Nothing
, _sscsivVolumeStatus = Nothing
, _sscsivSourceSnapshotId = Nothing
, _sscsivPreservedExistingData = Nothing
, _sscsivVolumeARN = Nothing
, _sscsivVolumeProgress = Nothing
, _sscsivVolumeSizeInBytes = Nothing
, _sscsivVolumeUsedInBytes = Nothing
, _sscsivCreatedDate = Nothing
, _sscsivVolumeId = Nothing
, _sscsivVolumeDiskId = Nothing
, _sscsivVolumeType = Nothing
}
sscsivVolumeiSCSIAttributes :: Lens' StorediSCSIVolume (Maybe VolumeiSCSIAttributes)
sscsivVolumeiSCSIAttributes = lens _sscsivVolumeiSCSIAttributes (\ s a -> s{_sscsivVolumeiSCSIAttributes = a})
sscsivVolumeStatus :: Lens' StorediSCSIVolume (Maybe Text)
sscsivVolumeStatus = lens _sscsivVolumeStatus (\ s a -> s{_sscsivVolumeStatus = a})
sscsivSourceSnapshotId :: Lens' StorediSCSIVolume (Maybe Text)
sscsivSourceSnapshotId = lens _sscsivSourceSnapshotId (\ s a -> s{_sscsivSourceSnapshotId = a})
sscsivPreservedExistingData :: Lens' StorediSCSIVolume (Maybe Bool)
sscsivPreservedExistingData = lens _sscsivPreservedExistingData (\ s a -> s{_sscsivPreservedExistingData = a})
sscsivVolumeARN :: Lens' StorediSCSIVolume (Maybe Text)
sscsivVolumeARN = lens _sscsivVolumeARN (\ s a -> s{_sscsivVolumeARN = a})
sscsivVolumeProgress :: Lens' StorediSCSIVolume (Maybe Double)
sscsivVolumeProgress = lens _sscsivVolumeProgress (\ s a -> s{_sscsivVolumeProgress = a})
sscsivVolumeSizeInBytes :: Lens' StorediSCSIVolume (Maybe Integer)
sscsivVolumeSizeInBytes = lens _sscsivVolumeSizeInBytes (\ s a -> s{_sscsivVolumeSizeInBytes = a})
sscsivVolumeUsedInBytes :: Lens' StorediSCSIVolume (Maybe Integer)
sscsivVolumeUsedInBytes = lens _sscsivVolumeUsedInBytes (\ s a -> s{_sscsivVolumeUsedInBytes = a})
sscsivCreatedDate :: Lens' StorediSCSIVolume (Maybe UTCTime)
sscsivCreatedDate = lens _sscsivCreatedDate (\ s a -> s{_sscsivCreatedDate = a}) . mapping _Time
sscsivVolumeId :: Lens' StorediSCSIVolume (Maybe Text)
sscsivVolumeId = lens _sscsivVolumeId (\ s a -> s{_sscsivVolumeId = a})
sscsivVolumeDiskId :: Lens' StorediSCSIVolume (Maybe Text)
sscsivVolumeDiskId = lens _sscsivVolumeDiskId (\ s a -> s{_sscsivVolumeDiskId = a})
sscsivVolumeType :: Lens' StorediSCSIVolume (Maybe Text)
sscsivVolumeType = lens _sscsivVolumeType (\ s a -> s{_sscsivVolumeType = a})
instance FromJSON StorediSCSIVolume where
parseJSON
= withObject "StorediSCSIVolume"
(\ x ->
StorediSCSIVolume' <$>
(x .:? "VolumeiSCSIAttributes") <*>
(x .:? "VolumeStatus")
<*> (x .:? "SourceSnapshotId")
<*> (x .:? "PreservedExistingData")
<*> (x .:? "VolumeARN")
<*> (x .:? "VolumeProgress")
<*> (x .:? "VolumeSizeInBytes")
<*> (x .:? "VolumeUsedInBytes")
<*> (x .:? "CreatedDate")
<*> (x .:? "VolumeId")
<*> (x .:? "VolumeDiskId")
<*> (x .:? "VolumeType"))
instance Hashable StorediSCSIVolume where
instance NFData StorediSCSIVolume where
data Tag = Tag'
{ _tagKey :: !Text
, _tagValue :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
tag
:: Text
-> Text
-> Tag
tag pKey_ pValue_ = Tag' {_tagKey = pKey_, _tagValue = pValue_}
tagKey :: Lens' Tag Text
tagKey = lens _tagKey (\ s a -> s{_tagKey = a})
tagValue :: Lens' Tag Text
tagValue = lens _tagValue (\ s a -> s{_tagValue = a})
instance FromJSON Tag where
parseJSON
= withObject "Tag"
(\ x -> Tag' <$> (x .: "Key") <*> (x .: "Value"))
instance Hashable Tag where
instance NFData Tag where
instance ToJSON Tag where
toJSON Tag'{..}
= object
(catMaybes
[Just ("Key" .= _tagKey),
Just ("Value" .= _tagValue)])
data Tape = Tape'
{ _tTapeBarcode :: !(Maybe Text)
, _tTapeStatus :: !(Maybe Text)
, _tTapeARN :: !(Maybe Text)
, _tProgress :: !(Maybe Double)
, _tTapeSizeInBytes :: !(Maybe Integer)
, _tVTLDevice :: !(Maybe Text)
, _tTapeUsedInBytes :: !(Maybe Integer)
, _tTapeCreatedDate :: !(Maybe POSIX)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
tape
:: Tape
tape =
Tape'
{ _tTapeBarcode = Nothing
, _tTapeStatus = Nothing
, _tTapeARN = Nothing
, _tProgress = Nothing
, _tTapeSizeInBytes = Nothing
, _tVTLDevice = Nothing
, _tTapeUsedInBytes = Nothing
, _tTapeCreatedDate = Nothing
}
tTapeBarcode :: Lens' Tape (Maybe Text)
tTapeBarcode = lens _tTapeBarcode (\ s a -> s{_tTapeBarcode = a})
tTapeStatus :: Lens' Tape (Maybe Text)
tTapeStatus = lens _tTapeStatus (\ s a -> s{_tTapeStatus = a})
tTapeARN :: Lens' Tape (Maybe Text)
tTapeARN = lens _tTapeARN (\ s a -> s{_tTapeARN = a})
tProgress :: Lens' Tape (Maybe Double)
tProgress = lens _tProgress (\ s a -> s{_tProgress = a})
tTapeSizeInBytes :: Lens' Tape (Maybe Integer)
tTapeSizeInBytes = lens _tTapeSizeInBytes (\ s a -> s{_tTapeSizeInBytes = a})
tVTLDevice :: Lens' Tape (Maybe Text)
tVTLDevice = lens _tVTLDevice (\ s a -> s{_tVTLDevice = a})
tTapeUsedInBytes :: Lens' Tape (Maybe Integer)
tTapeUsedInBytes = lens _tTapeUsedInBytes (\ s a -> s{_tTapeUsedInBytes = a})
tTapeCreatedDate :: Lens' Tape (Maybe UTCTime)
tTapeCreatedDate = lens _tTapeCreatedDate (\ s a -> s{_tTapeCreatedDate = a}) . mapping _Time
instance FromJSON Tape where
parseJSON
= withObject "Tape"
(\ x ->
Tape' <$>
(x .:? "TapeBarcode") <*> (x .:? "TapeStatus") <*>
(x .:? "TapeARN")
<*> (x .:? "Progress")
<*> (x .:? "TapeSizeInBytes")
<*> (x .:? "VTLDevice")
<*> (x .:? "TapeUsedInBytes")
<*> (x .:? "TapeCreatedDate"))
instance Hashable Tape where
instance NFData Tape where
data TapeArchive = TapeArchive'
{ _taTapeBarcode :: !(Maybe Text)
, _taTapeStatus :: !(Maybe Text)
, _taTapeARN :: !(Maybe Text)
, _taTapeSizeInBytes :: !(Maybe Integer)
, _taCompletionTime :: !(Maybe POSIX)
, _taTapeUsedInBytes :: !(Maybe Integer)
, _taTapeCreatedDate :: !(Maybe POSIX)
, _taRetrievedTo :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
tapeArchive
:: TapeArchive
tapeArchive =
TapeArchive'
{ _taTapeBarcode = Nothing
, _taTapeStatus = Nothing
, _taTapeARN = Nothing
, _taTapeSizeInBytes = Nothing
, _taCompletionTime = Nothing
, _taTapeUsedInBytes = Nothing
, _taTapeCreatedDate = Nothing
, _taRetrievedTo = Nothing
}
taTapeBarcode :: Lens' TapeArchive (Maybe Text)
taTapeBarcode = lens _taTapeBarcode (\ s a -> s{_taTapeBarcode = a})
taTapeStatus :: Lens' TapeArchive (Maybe Text)
taTapeStatus = lens _taTapeStatus (\ s a -> s{_taTapeStatus = a})
taTapeARN :: Lens' TapeArchive (Maybe Text)
taTapeARN = lens _taTapeARN (\ s a -> s{_taTapeARN = a})
taTapeSizeInBytes :: Lens' TapeArchive (Maybe Integer)
taTapeSizeInBytes = lens _taTapeSizeInBytes (\ s a -> s{_taTapeSizeInBytes = a})
taCompletionTime :: Lens' TapeArchive (Maybe UTCTime)
taCompletionTime = lens _taCompletionTime (\ s a -> s{_taCompletionTime = a}) . mapping _Time
taTapeUsedInBytes :: Lens' TapeArchive (Maybe Integer)
taTapeUsedInBytes = lens _taTapeUsedInBytes (\ s a -> s{_taTapeUsedInBytes = a})
taTapeCreatedDate :: Lens' TapeArchive (Maybe UTCTime)
taTapeCreatedDate = lens _taTapeCreatedDate (\ s a -> s{_taTapeCreatedDate = a}) . mapping _Time
taRetrievedTo :: Lens' TapeArchive (Maybe Text)
taRetrievedTo = lens _taRetrievedTo (\ s a -> s{_taRetrievedTo = a})
instance FromJSON TapeArchive where
parseJSON
= withObject "TapeArchive"
(\ x ->
TapeArchive' <$>
(x .:? "TapeBarcode") <*> (x .:? "TapeStatus") <*>
(x .:? "TapeARN")
<*> (x .:? "TapeSizeInBytes")
<*> (x .:? "CompletionTime")
<*> (x .:? "TapeUsedInBytes")
<*> (x .:? "TapeCreatedDate")
<*> (x .:? "RetrievedTo"))
instance Hashable TapeArchive where
instance NFData TapeArchive where
data TapeInfo = TapeInfo'
{ _tiTapeBarcode :: !(Maybe Text)
, _tiTapeStatus :: !(Maybe Text)
, _tiTapeARN :: !(Maybe Text)
, _tiGatewayARN :: !(Maybe Text)
, _tiTapeSizeInBytes :: !(Maybe Integer)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
tapeInfo
:: TapeInfo
tapeInfo =
TapeInfo'
{ _tiTapeBarcode = Nothing
, _tiTapeStatus = Nothing
, _tiTapeARN = Nothing
, _tiGatewayARN = Nothing
, _tiTapeSizeInBytes = Nothing
}
tiTapeBarcode :: Lens' TapeInfo (Maybe Text)
tiTapeBarcode = lens _tiTapeBarcode (\ s a -> s{_tiTapeBarcode = a})
tiTapeStatus :: Lens' TapeInfo (Maybe Text)
tiTapeStatus = lens _tiTapeStatus (\ s a -> s{_tiTapeStatus = a})
tiTapeARN :: Lens' TapeInfo (Maybe Text)
tiTapeARN = lens _tiTapeARN (\ s a -> s{_tiTapeARN = a})
tiGatewayARN :: Lens' TapeInfo (Maybe Text)
tiGatewayARN = lens _tiGatewayARN (\ s a -> s{_tiGatewayARN = a})
tiTapeSizeInBytes :: Lens' TapeInfo (Maybe Integer)
tiTapeSizeInBytes = lens _tiTapeSizeInBytes (\ s a -> s{_tiTapeSizeInBytes = a})
instance FromJSON TapeInfo where
parseJSON
= withObject "TapeInfo"
(\ x ->
TapeInfo' <$>
(x .:? "TapeBarcode") <*> (x .:? "TapeStatus") <*>
(x .:? "TapeARN")
<*> (x .:? "GatewayARN")
<*> (x .:? "TapeSizeInBytes"))
instance Hashable TapeInfo where
instance NFData TapeInfo where
data TapeRecoveryPointInfo = TapeRecoveryPointInfo'
{ _trpiTapeStatus :: !(Maybe Text)
, _trpiTapeRecoveryPointTime :: !(Maybe POSIX)
, _trpiTapeARN :: !(Maybe Text)
, _trpiTapeSizeInBytes :: !(Maybe Integer)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
tapeRecoveryPointInfo
:: TapeRecoveryPointInfo
tapeRecoveryPointInfo =
TapeRecoveryPointInfo'
{ _trpiTapeStatus = Nothing
, _trpiTapeRecoveryPointTime = Nothing
, _trpiTapeARN = Nothing
, _trpiTapeSizeInBytes = Nothing
}
trpiTapeStatus :: Lens' TapeRecoveryPointInfo (Maybe Text)
trpiTapeStatus = lens _trpiTapeStatus (\ s a -> s{_trpiTapeStatus = a})
trpiTapeRecoveryPointTime :: Lens' TapeRecoveryPointInfo (Maybe UTCTime)
trpiTapeRecoveryPointTime = lens _trpiTapeRecoveryPointTime (\ s a -> s{_trpiTapeRecoveryPointTime = a}) . mapping _Time
trpiTapeARN :: Lens' TapeRecoveryPointInfo (Maybe Text)
trpiTapeARN = lens _trpiTapeARN (\ s a -> s{_trpiTapeARN = a})
trpiTapeSizeInBytes :: Lens' TapeRecoveryPointInfo (Maybe Integer)
trpiTapeSizeInBytes = lens _trpiTapeSizeInBytes (\ s a -> s{_trpiTapeSizeInBytes = a})
instance FromJSON TapeRecoveryPointInfo where
parseJSON
= withObject "TapeRecoveryPointInfo"
(\ x ->
TapeRecoveryPointInfo' <$>
(x .:? "TapeStatus") <*>
(x .:? "TapeRecoveryPointTime")
<*> (x .:? "TapeARN")
<*> (x .:? "TapeSizeInBytes"))
instance Hashable TapeRecoveryPointInfo where
instance NFData TapeRecoveryPointInfo where
data VTLDevice = VTLDevice'
{ _vtldDeviceiSCSIAttributes :: !(Maybe DeviceiSCSIAttributes)
, _vtldVTLDeviceVendor :: !(Maybe Text)
, _vtldVTLDeviceARN :: !(Maybe Text)
, _vtldVTLDeviceType :: !(Maybe Text)
, _vtldVTLDeviceProductIdentifier :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
vTLDevice
:: VTLDevice
vTLDevice =
VTLDevice'
{ _vtldDeviceiSCSIAttributes = Nothing
, _vtldVTLDeviceVendor = Nothing
, _vtldVTLDeviceARN = Nothing
, _vtldVTLDeviceType = Nothing
, _vtldVTLDeviceProductIdentifier = Nothing
}
vtldDeviceiSCSIAttributes :: Lens' VTLDevice (Maybe DeviceiSCSIAttributes)
vtldDeviceiSCSIAttributes = lens _vtldDeviceiSCSIAttributes (\ s a -> s{_vtldDeviceiSCSIAttributes = a})
vtldVTLDeviceVendor :: Lens' VTLDevice (Maybe Text)
vtldVTLDeviceVendor = lens _vtldVTLDeviceVendor (\ s a -> s{_vtldVTLDeviceVendor = a})
vtldVTLDeviceARN :: Lens' VTLDevice (Maybe Text)
vtldVTLDeviceARN = lens _vtldVTLDeviceARN (\ s a -> s{_vtldVTLDeviceARN = a})
vtldVTLDeviceType :: Lens' VTLDevice (Maybe Text)
vtldVTLDeviceType = lens _vtldVTLDeviceType (\ s a -> s{_vtldVTLDeviceType = a})
vtldVTLDeviceProductIdentifier :: Lens' VTLDevice (Maybe Text)
vtldVTLDeviceProductIdentifier = lens _vtldVTLDeviceProductIdentifier (\ s a -> s{_vtldVTLDeviceProductIdentifier = a})
instance FromJSON VTLDevice where
parseJSON
= withObject "VTLDevice"
(\ x ->
VTLDevice' <$>
(x .:? "DeviceiSCSIAttributes") <*>
(x .:? "VTLDeviceVendor")
<*> (x .:? "VTLDeviceARN")
<*> (x .:? "VTLDeviceType")
<*> (x .:? "VTLDeviceProductIdentifier"))
instance Hashable VTLDevice where
instance NFData VTLDevice where
data VolumeInfo = VolumeInfo'
{ _viGatewayARN :: !(Maybe Text)
, _viVolumeARN :: !(Maybe Text)
, _viVolumeSizeInBytes :: !(Maybe Integer)
, _viVolumeId :: !(Maybe Text)
, _viGatewayId :: !(Maybe Text)
, _viVolumeType :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
volumeInfo
:: VolumeInfo
volumeInfo =
VolumeInfo'
{ _viGatewayARN = Nothing
, _viVolumeARN = Nothing
, _viVolumeSizeInBytes = Nothing
, _viVolumeId = Nothing
, _viGatewayId = Nothing
, _viVolumeType = Nothing
}
viGatewayARN :: Lens' VolumeInfo (Maybe Text)
viGatewayARN = lens _viGatewayARN (\ s a -> s{_viGatewayARN = a})
viVolumeARN :: Lens' VolumeInfo (Maybe Text)
viVolumeARN = lens _viVolumeARN (\ s a -> s{_viVolumeARN = a})
viVolumeSizeInBytes :: Lens' VolumeInfo (Maybe Integer)
viVolumeSizeInBytes = lens _viVolumeSizeInBytes (\ s a -> s{_viVolumeSizeInBytes = a})
viVolumeId :: Lens' VolumeInfo (Maybe Text)
viVolumeId = lens _viVolumeId (\ s a -> s{_viVolumeId = a})
viGatewayId :: Lens' VolumeInfo (Maybe Text)
viGatewayId = lens _viGatewayId (\ s a -> s{_viGatewayId = a})
viVolumeType :: Lens' VolumeInfo (Maybe Text)
viVolumeType = lens _viVolumeType (\ s a -> s{_viVolumeType = a})
instance FromJSON VolumeInfo where
parseJSON
= withObject "VolumeInfo"
(\ x ->
VolumeInfo' <$>
(x .:? "GatewayARN") <*> (x .:? "VolumeARN") <*>
(x .:? "VolumeSizeInBytes")
<*> (x .:? "VolumeId")
<*> (x .:? "GatewayId")
<*> (x .:? "VolumeType"))
instance Hashable VolumeInfo where
instance NFData VolumeInfo where
data VolumeRecoveryPointInfo = VolumeRecoveryPointInfo'
{ _vrpiVolumeRecoveryPointTime :: !(Maybe Text)
, _vrpiVolumeARN :: !(Maybe Text)
, _vrpiVolumeSizeInBytes :: !(Maybe Integer)
, _vrpiVolumeUsageInBytes :: !(Maybe Integer)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
volumeRecoveryPointInfo
:: VolumeRecoveryPointInfo
volumeRecoveryPointInfo =
VolumeRecoveryPointInfo'
{ _vrpiVolumeRecoveryPointTime = Nothing
, _vrpiVolumeARN = Nothing
, _vrpiVolumeSizeInBytes = Nothing
, _vrpiVolumeUsageInBytes = Nothing
}
vrpiVolumeRecoveryPointTime :: Lens' VolumeRecoveryPointInfo (Maybe Text)
vrpiVolumeRecoveryPointTime = lens _vrpiVolumeRecoveryPointTime (\ s a -> s{_vrpiVolumeRecoveryPointTime = a})
vrpiVolumeARN :: Lens' VolumeRecoveryPointInfo (Maybe Text)
vrpiVolumeARN = lens _vrpiVolumeARN (\ s a -> s{_vrpiVolumeARN = a})
vrpiVolumeSizeInBytes :: Lens' VolumeRecoveryPointInfo (Maybe Integer)
vrpiVolumeSizeInBytes = lens _vrpiVolumeSizeInBytes (\ s a -> s{_vrpiVolumeSizeInBytes = a})
vrpiVolumeUsageInBytes :: Lens' VolumeRecoveryPointInfo (Maybe Integer)
vrpiVolumeUsageInBytes = lens _vrpiVolumeUsageInBytes (\ s a -> s{_vrpiVolumeUsageInBytes = a})
instance FromJSON VolumeRecoveryPointInfo where
parseJSON
= withObject "VolumeRecoveryPointInfo"
(\ x ->
VolumeRecoveryPointInfo' <$>
(x .:? "VolumeRecoveryPointTime") <*>
(x .:? "VolumeARN")
<*> (x .:? "VolumeSizeInBytes")
<*> (x .:? "VolumeUsageInBytes"))
instance Hashable VolumeRecoveryPointInfo where
instance NFData VolumeRecoveryPointInfo where
data VolumeiSCSIAttributes = VolumeiSCSIAttributes'
{ _vscsiaLunNumber :: !(Maybe Nat)
, _vscsiaTargetARN :: !(Maybe Text)
, _vscsiaChapEnabled :: !(Maybe Bool)
, _vscsiaNetworkInterfaceId :: !(Maybe Text)
, _vscsiaNetworkInterfacePort :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
volumeiSCSIAttributes
:: VolumeiSCSIAttributes
volumeiSCSIAttributes =
VolumeiSCSIAttributes'
{ _vscsiaLunNumber = Nothing
, _vscsiaTargetARN = Nothing
, _vscsiaChapEnabled = Nothing
, _vscsiaNetworkInterfaceId = Nothing
, _vscsiaNetworkInterfacePort = Nothing
}
vscsiaLunNumber :: Lens' VolumeiSCSIAttributes (Maybe Natural)
vscsiaLunNumber = lens _vscsiaLunNumber (\ s a -> s{_vscsiaLunNumber = a}) . mapping _Nat
vscsiaTargetARN :: Lens' VolumeiSCSIAttributes (Maybe Text)
vscsiaTargetARN = lens _vscsiaTargetARN (\ s a -> s{_vscsiaTargetARN = a})
vscsiaChapEnabled :: Lens' VolumeiSCSIAttributes (Maybe Bool)
vscsiaChapEnabled = lens _vscsiaChapEnabled (\ s a -> s{_vscsiaChapEnabled = a})
vscsiaNetworkInterfaceId :: Lens' VolumeiSCSIAttributes (Maybe Text)
vscsiaNetworkInterfaceId = lens _vscsiaNetworkInterfaceId (\ s a -> s{_vscsiaNetworkInterfaceId = a})
vscsiaNetworkInterfacePort :: Lens' VolumeiSCSIAttributes (Maybe Int)
vscsiaNetworkInterfacePort = lens _vscsiaNetworkInterfacePort (\ s a -> s{_vscsiaNetworkInterfacePort = a})
instance FromJSON VolumeiSCSIAttributes where
parseJSON
= withObject "VolumeiSCSIAttributes"
(\ x ->
VolumeiSCSIAttributes' <$>
(x .:? "LunNumber") <*> (x .:? "TargetARN") <*>
(x .:? "ChapEnabled")
<*> (x .:? "NetworkInterfaceId")
<*> (x .:? "NetworkInterfacePort"))
instance Hashable VolumeiSCSIAttributes where
instance NFData VolumeiSCSIAttributes where