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)
, _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
, _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});
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 .:? "VolumeId")
<*> (x .:? "VolumeType"))
instance Hashable CachediSCSIVolume
instance NFData CachediSCSIVolume
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
instance NFData ChapInfo
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
instance NFData DeviceiSCSIAttributes
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
instance NFData Disk
data GatewayInfo = GatewayInfo'
{ _giGatewayARN :: !(Maybe Text)
, _giGatewayOperationalState :: !(Maybe Text)
, _giGatewayName :: !(Maybe Text)
, _giGatewayType :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
gatewayInfo
:: GatewayInfo
gatewayInfo =
GatewayInfo'
{ _giGatewayARN = Nothing
, _giGatewayOperationalState = Nothing
, _giGatewayName = 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});
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 .:? "GatewayType"))
instance Hashable GatewayInfo
instance NFData GatewayInfo
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
instance NFData NetworkInterface
data StorediSCSIVolume = StorediSCSIVolume'
{ _sscsivVolumeiSCSIAttributes :: !(Maybe VolumeiSCSIAttributes)
, _sscsivVolumeStatus :: !(Maybe Text)
, _sscsivSourceSnapshotId :: !(Maybe Text)
, _sscsivPreservedExistingData :: !(Maybe Bool)
, _sscsivVolumeARN :: !(Maybe Text)
, _sscsivVolumeProgress :: !(Maybe Double)
, _sscsivVolumeSizeInBytes :: !(Maybe Integer)
, _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
, _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});
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 .:? "VolumeId")
<*> (x .:? "VolumeDiskId")
<*> (x .:? "VolumeType"))
instance Hashable StorediSCSIVolume
instance NFData StorediSCSIVolume
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
instance NFData Tag
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)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
tape
:: Tape
tape =
Tape'
{ _tTapeBarcode = Nothing
, _tTapeStatus = Nothing
, _tTapeARN = Nothing
, _tProgress = Nothing
, _tTapeSizeInBytes = Nothing
, _tVTLDevice = 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});
instance FromJSON Tape where
parseJSON
= withObject "Tape"
(\ x ->
Tape' <$>
(x .:? "TapeBarcode") <*> (x .:? "TapeStatus") <*>
(x .:? "TapeARN")
<*> (x .:? "Progress")
<*> (x .:? "TapeSizeInBytes")
<*> (x .:? "VTLDevice"))
instance Hashable Tape
instance NFData Tape
data TapeArchive = TapeArchive'
{ _taTapeBarcode :: !(Maybe Text)
, _taTapeStatus :: !(Maybe Text)
, _taTapeARN :: !(Maybe Text)
, _taTapeSizeInBytes :: !(Maybe Integer)
, _taCompletionTime :: !(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
, _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;
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 .:? "RetrievedTo"))
instance Hashable TapeArchive
instance NFData TapeArchive
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
instance NFData TapeRecoveryPointInfo
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
instance NFData VTLDevice
data VolumeInfo = VolumeInfo'
{ _viVolumeARN :: !(Maybe Text)
, _viVolumeType :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
volumeInfo
:: VolumeInfo
volumeInfo =
VolumeInfo'
{ _viVolumeARN = Nothing
, _viVolumeType = Nothing
}
viVolumeARN :: Lens' VolumeInfo (Maybe Text)
viVolumeARN = lens _viVolumeARN (\ s a -> s{_viVolumeARN = a});
viVolumeType :: Lens' VolumeInfo (Maybe Text)
viVolumeType = lens _viVolumeType (\ s a -> s{_viVolumeType = a});
instance FromJSON VolumeInfo where
parseJSON
= withObject "VolumeInfo"
(\ x ->
VolumeInfo' <$>
(x .:? "VolumeARN") <*> (x .:? "VolumeType"))
instance Hashable VolumeInfo
instance NFData VolumeInfo
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
instance NFData VolumeRecoveryPointInfo
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
instance NFData VolumeiSCSIAttributes