diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,20 @@ +Copyright (c) 2016 David Reaver +Copyright (c) 2022 Markus Schirp + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/gen/Stratosphere/EFS/AccessPoint.hs b/gen/Stratosphere/EFS/AccessPoint.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint.hs @@ -0,0 +1,74 @@ +module Stratosphere.EFS.AccessPoint ( + module Exports, AccessPoint(..), mkAccessPoint + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EFS.AccessPoint.AccessPointTagProperty as Exports +import {-# SOURCE #-} Stratosphere.EFS.AccessPoint.PosixUserProperty as Exports +import {-# SOURCE #-} Stratosphere.EFS.AccessPoint.RootDirectoryProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AccessPoint + = -- | See: + AccessPoint {haddock_workaround_ :: (), + -- | See: + accessPointTags :: (Prelude.Maybe [AccessPointTagProperty]), + -- | See: + clientToken :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + fileSystemId :: (Value Prelude.Text), + -- | See: + posixUser :: (Prelude.Maybe PosixUserProperty), + -- | See: + rootDirectory :: (Prelude.Maybe RootDirectoryProperty)} + deriving stock (Prelude.Eq, Prelude.Show) +mkAccessPoint :: Value Prelude.Text -> AccessPoint +mkAccessPoint fileSystemId + = AccessPoint + {haddock_workaround_ = (), fileSystemId = fileSystemId, + accessPointTags = Prelude.Nothing, clientToken = Prelude.Nothing, + posixUser = Prelude.Nothing, rootDirectory = Prelude.Nothing} +instance ToResourceProperties AccessPoint where + toResourceProperties AccessPoint {..} + = ResourceProperties + {awsType = "AWS::EFS::AccessPoint", supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["FileSystemId" JSON..= fileSystemId] + (Prelude.catMaybes + [(JSON..=) "AccessPointTags" Prelude.<$> accessPointTags, + (JSON..=) "ClientToken" Prelude.<$> clientToken, + (JSON..=) "PosixUser" Prelude.<$> posixUser, + (JSON..=) "RootDirectory" Prelude.<$> rootDirectory]))} +instance JSON.ToJSON AccessPoint where + toJSON AccessPoint {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["FileSystemId" JSON..= fileSystemId] + (Prelude.catMaybes + [(JSON..=) "AccessPointTags" Prelude.<$> accessPointTags, + (JSON..=) "ClientToken" Prelude.<$> clientToken, + (JSON..=) "PosixUser" Prelude.<$> posixUser, + (JSON..=) "RootDirectory" Prelude.<$> rootDirectory]))) +instance Property "AccessPointTags" AccessPoint where + type PropertyType "AccessPointTags" AccessPoint = [AccessPointTagProperty] + set newValue AccessPoint {..} + = AccessPoint {accessPointTags = Prelude.pure newValue, ..} +instance Property "ClientToken" AccessPoint where + type PropertyType "ClientToken" AccessPoint = Value Prelude.Text + set newValue AccessPoint {..} + = AccessPoint {clientToken = Prelude.pure newValue, ..} +instance Property "FileSystemId" AccessPoint where + type PropertyType "FileSystemId" AccessPoint = Value Prelude.Text + set newValue AccessPoint {..} + = AccessPoint {fileSystemId = newValue, ..} +instance Property "PosixUser" AccessPoint where + type PropertyType "PosixUser" AccessPoint = PosixUserProperty + set newValue AccessPoint {..} + = AccessPoint {posixUser = Prelude.pure newValue, ..} +instance Property "RootDirectory" AccessPoint where + type PropertyType "RootDirectory" AccessPoint = RootDirectoryProperty + set newValue AccessPoint {..} + = AccessPoint {rootDirectory = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/AccessPoint/AccessPointTagProperty.hs b/gen/Stratosphere/EFS/AccessPoint/AccessPointTagProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/AccessPointTagProperty.hs @@ -0,0 +1,45 @@ +module Stratosphere.EFS.AccessPoint.AccessPointTagProperty ( + AccessPointTagProperty(..), mkAccessPointTagProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data AccessPointTagProperty + = -- | See: + AccessPointTagProperty {haddock_workaround_ :: (), + -- | See: + key :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + value :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkAccessPointTagProperty :: AccessPointTagProperty +mkAccessPointTagProperty + = AccessPointTagProperty + {haddock_workaround_ = (), key = Prelude.Nothing, + value = Prelude.Nothing} +instance ToResourceProperties AccessPointTagProperty where + toResourceProperties AccessPointTagProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::AccessPoint.AccessPointTag", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Key" Prelude.<$> key, + (JSON..=) "Value" Prelude.<$> value])} +instance JSON.ToJSON AccessPointTagProperty where + toJSON AccessPointTagProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Key" Prelude.<$> key, + (JSON..=) "Value" Prelude.<$> value])) +instance Property "Key" AccessPointTagProperty where + type PropertyType "Key" AccessPointTagProperty = Value Prelude.Text + set newValue AccessPointTagProperty {..} + = AccessPointTagProperty {key = Prelude.pure newValue, ..} +instance Property "Value" AccessPointTagProperty where + type PropertyType "Value" AccessPointTagProperty = Value Prelude.Text + set newValue AccessPointTagProperty {..} + = AccessPointTagProperty {value = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/AccessPoint/AccessPointTagProperty.hs-boot b/gen/Stratosphere/EFS/AccessPoint/AccessPointTagProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/AccessPointTagProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.AccessPoint.AccessPointTagProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data AccessPointTagProperty :: Prelude.Type +instance ToResourceProperties AccessPointTagProperty +instance Prelude.Eq AccessPointTagProperty +instance Prelude.Show AccessPointTagProperty +instance JSON.ToJSON AccessPointTagProperty diff --git a/gen/Stratosphere/EFS/AccessPoint/CreationInfoProperty.hs b/gen/Stratosphere/EFS/AccessPoint/CreationInfoProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/CreationInfoProperty.hs @@ -0,0 +1,49 @@ +module Stratosphere.EFS.AccessPoint.CreationInfoProperty ( + CreationInfoProperty(..), mkCreationInfoProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data CreationInfoProperty + = -- | See: + CreationInfoProperty {haddock_workaround_ :: (), + -- | See: + ownerGid :: (Value Prelude.Text), + -- | See: + ownerUid :: (Value Prelude.Text), + -- | See: + permissions :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkCreationInfoProperty :: + Value Prelude.Text + -> Value Prelude.Text -> Value Prelude.Text -> CreationInfoProperty +mkCreationInfoProperty ownerGid ownerUid permissions + = CreationInfoProperty + {haddock_workaround_ = (), ownerGid = ownerGid, + ownerUid = ownerUid, permissions = permissions} +instance ToResourceProperties CreationInfoProperty where + toResourceProperties CreationInfoProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::AccessPoint.CreationInfo", + supportsTags = Prelude.False, + properties = ["OwnerGid" JSON..= ownerGid, + "OwnerUid" JSON..= ownerUid, "Permissions" JSON..= permissions]} +instance JSON.ToJSON CreationInfoProperty where + toJSON CreationInfoProperty {..} + = JSON.object + ["OwnerGid" JSON..= ownerGid, "OwnerUid" JSON..= ownerUid, + "Permissions" JSON..= permissions] +instance Property "OwnerGid" CreationInfoProperty where + type PropertyType "OwnerGid" CreationInfoProperty = Value Prelude.Text + set newValue CreationInfoProperty {..} + = CreationInfoProperty {ownerGid = newValue, ..} +instance Property "OwnerUid" CreationInfoProperty where + type PropertyType "OwnerUid" CreationInfoProperty = Value Prelude.Text + set newValue CreationInfoProperty {..} + = CreationInfoProperty {ownerUid = newValue, ..} +instance Property "Permissions" CreationInfoProperty where + type PropertyType "Permissions" CreationInfoProperty = Value Prelude.Text + set newValue CreationInfoProperty {..} + = CreationInfoProperty {permissions = newValue, ..} diff --git a/gen/Stratosphere/EFS/AccessPoint/CreationInfoProperty.hs-boot b/gen/Stratosphere/EFS/AccessPoint/CreationInfoProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/CreationInfoProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.AccessPoint.CreationInfoProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data CreationInfoProperty :: Prelude.Type +instance ToResourceProperties CreationInfoProperty +instance Prelude.Eq CreationInfoProperty +instance Prelude.Show CreationInfoProperty +instance JSON.ToJSON CreationInfoProperty diff --git a/gen/Stratosphere/EFS/AccessPoint/PosixUserProperty.hs b/gen/Stratosphere/EFS/AccessPoint/PosixUserProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/PosixUserProperty.hs @@ -0,0 +1,54 @@ +module Stratosphere.EFS.AccessPoint.PosixUserProperty ( + PosixUserProperty(..), mkPosixUserProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data PosixUserProperty + = -- | See: + PosixUserProperty {haddock_workaround_ :: (), + -- | See: + gid :: (Value Prelude.Text), + -- | See: + secondaryGids :: (Prelude.Maybe (ValueList Prelude.Text)), + -- | See: + uid :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkPosixUserProperty :: + Value Prelude.Text -> Value Prelude.Text -> PosixUserProperty +mkPosixUserProperty gid uid + = PosixUserProperty + {haddock_workaround_ = (), gid = gid, uid = uid, + secondaryGids = Prelude.Nothing} +instance ToResourceProperties PosixUserProperty where + toResourceProperties PosixUserProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::AccessPoint.PosixUser", + supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["Gid" JSON..= gid, "Uid" JSON..= uid] + (Prelude.catMaybes + [(JSON..=) "SecondaryGids" Prelude.<$> secondaryGids]))} +instance JSON.ToJSON PosixUserProperty where + toJSON PosixUserProperty {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["Gid" JSON..= gid, "Uid" JSON..= uid] + (Prelude.catMaybes + [(JSON..=) "SecondaryGids" Prelude.<$> secondaryGids]))) +instance Property "Gid" PosixUserProperty where + type PropertyType "Gid" PosixUserProperty = Value Prelude.Text + set newValue PosixUserProperty {..} + = PosixUserProperty {gid = newValue, ..} +instance Property "SecondaryGids" PosixUserProperty where + type PropertyType "SecondaryGids" PosixUserProperty = ValueList Prelude.Text + set newValue PosixUserProperty {..} + = PosixUserProperty {secondaryGids = Prelude.pure newValue, ..} +instance Property "Uid" PosixUserProperty where + type PropertyType "Uid" PosixUserProperty = Value Prelude.Text + set newValue PosixUserProperty {..} + = PosixUserProperty {uid = newValue, ..} diff --git a/gen/Stratosphere/EFS/AccessPoint/PosixUserProperty.hs-boot b/gen/Stratosphere/EFS/AccessPoint/PosixUserProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/PosixUserProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.AccessPoint.PosixUserProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data PosixUserProperty :: Prelude.Type +instance ToResourceProperties PosixUserProperty +instance Prelude.Eq PosixUserProperty +instance Prelude.Show PosixUserProperty +instance JSON.ToJSON PosixUserProperty diff --git a/gen/Stratosphere/EFS/AccessPoint/RootDirectoryProperty.hs b/gen/Stratosphere/EFS/AccessPoint/RootDirectoryProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/RootDirectoryProperty.hs @@ -0,0 +1,46 @@ +module Stratosphere.EFS.AccessPoint.RootDirectoryProperty ( + module Exports, RootDirectoryProperty(..), mkRootDirectoryProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EFS.AccessPoint.CreationInfoProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data RootDirectoryProperty + = -- | See: + RootDirectoryProperty {haddock_workaround_ :: (), + -- | See: + creationInfo :: (Prelude.Maybe CreationInfoProperty), + -- | See: + path :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkRootDirectoryProperty :: RootDirectoryProperty +mkRootDirectoryProperty + = RootDirectoryProperty + {haddock_workaround_ = (), creationInfo = Prelude.Nothing, + path = Prelude.Nothing} +instance ToResourceProperties RootDirectoryProperty where + toResourceProperties RootDirectoryProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::AccessPoint.RootDirectory", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CreationInfo" Prelude.<$> creationInfo, + (JSON..=) "Path" Prelude.<$> path])} +instance JSON.ToJSON RootDirectoryProperty where + toJSON RootDirectoryProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "CreationInfo" Prelude.<$> creationInfo, + (JSON..=) "Path" Prelude.<$> path])) +instance Property "CreationInfo" RootDirectoryProperty where + type PropertyType "CreationInfo" RootDirectoryProperty = CreationInfoProperty + set newValue RootDirectoryProperty {..} + = RootDirectoryProperty {creationInfo = Prelude.pure newValue, ..} +instance Property "Path" RootDirectoryProperty where + type PropertyType "Path" RootDirectoryProperty = Value Prelude.Text + set newValue RootDirectoryProperty {..} + = RootDirectoryProperty {path = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/AccessPoint/RootDirectoryProperty.hs-boot b/gen/Stratosphere/EFS/AccessPoint/RootDirectoryProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/AccessPoint/RootDirectoryProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.AccessPoint.RootDirectoryProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data RootDirectoryProperty :: Prelude.Type +instance ToResourceProperties RootDirectoryProperty +instance Prelude.Eq RootDirectoryProperty +instance Prelude.Show RootDirectoryProperty +instance JSON.ToJSON RootDirectoryProperty diff --git a/gen/Stratosphere/EFS/FileSystem.hs b/gen/Stratosphere/EFS/FileSystem.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem.hs @@ -0,0 +1,154 @@ +module Stratosphere.EFS.FileSystem ( + module Exports, FileSystem(..), mkFileSystem + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EFS.FileSystem.BackupPolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.EFS.FileSystem.ElasticFileSystemTagProperty as Exports +import {-# SOURCE #-} Stratosphere.EFS.FileSystem.FileSystemProtectionProperty as Exports +import {-# SOURCE #-} Stratosphere.EFS.FileSystem.LifecyclePolicyProperty as Exports +import {-# SOURCE #-} Stratosphere.EFS.FileSystem.ReplicationConfigurationProperty as Exports +import Stratosphere.ResourceProperties +import Stratosphere.Value +data FileSystem + = -- | See: + FileSystem {haddock_workaround_ :: (), + -- | See: + availabilityZoneName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + backupPolicy :: (Prelude.Maybe BackupPolicyProperty), + -- | See: + bypassPolicyLockoutSafetyCheck :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + encrypted :: (Prelude.Maybe (Value Prelude.Bool)), + -- | See: + fileSystemPolicy :: (Prelude.Maybe JSON.Object), + -- | See: + fileSystemProtection :: (Prelude.Maybe FileSystemProtectionProperty), + -- | See: + fileSystemTags :: (Prelude.Maybe [ElasticFileSystemTagProperty]), + -- | See: + kmsKeyId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + lifecyclePolicies :: (Prelude.Maybe [LifecyclePolicyProperty]), + -- | See: + performanceMode :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + provisionedThroughputInMibps :: (Prelude.Maybe (Value Prelude.Double)), + -- | See: + replicationConfiguration :: (Prelude.Maybe ReplicationConfigurationProperty), + -- | See: + throughputMode :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkFileSystem :: FileSystem +mkFileSystem + = FileSystem + {haddock_workaround_ = (), availabilityZoneName = Prelude.Nothing, + backupPolicy = Prelude.Nothing, + bypassPolicyLockoutSafetyCheck = Prelude.Nothing, + encrypted = Prelude.Nothing, fileSystemPolicy = Prelude.Nothing, + fileSystemProtection = Prelude.Nothing, + fileSystemTags = Prelude.Nothing, kmsKeyId = Prelude.Nothing, + lifecyclePolicies = Prelude.Nothing, + performanceMode = Prelude.Nothing, + provisionedThroughputInMibps = Prelude.Nothing, + replicationConfiguration = Prelude.Nothing, + throughputMode = Prelude.Nothing} +instance ToResourceProperties FileSystem where + toResourceProperties FileSystem {..} + = ResourceProperties + {awsType = "AWS::EFS::FileSystem", supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AvailabilityZoneName" Prelude.<$> availabilityZoneName, + (JSON..=) "BackupPolicy" Prelude.<$> backupPolicy, + (JSON..=) "BypassPolicyLockoutSafetyCheck" + Prelude.<$> bypassPolicyLockoutSafetyCheck, + (JSON..=) "Encrypted" Prelude.<$> encrypted, + (JSON..=) "FileSystemPolicy" Prelude.<$> fileSystemPolicy, + (JSON..=) "FileSystemProtection" Prelude.<$> fileSystemProtection, + (JSON..=) "FileSystemTags" Prelude.<$> fileSystemTags, + (JSON..=) "KmsKeyId" Prelude.<$> kmsKeyId, + (JSON..=) "LifecyclePolicies" Prelude.<$> lifecyclePolicies, + (JSON..=) "PerformanceMode" Prelude.<$> performanceMode, + (JSON..=) "ProvisionedThroughputInMibps" + Prelude.<$> provisionedThroughputInMibps, + (JSON..=) "ReplicationConfiguration" + Prelude.<$> replicationConfiguration, + (JSON..=) "ThroughputMode" Prelude.<$> throughputMode])} +instance JSON.ToJSON FileSystem where + toJSON FileSystem {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AvailabilityZoneName" Prelude.<$> availabilityZoneName, + (JSON..=) "BackupPolicy" Prelude.<$> backupPolicy, + (JSON..=) "BypassPolicyLockoutSafetyCheck" + Prelude.<$> bypassPolicyLockoutSafetyCheck, + (JSON..=) "Encrypted" Prelude.<$> encrypted, + (JSON..=) "FileSystemPolicy" Prelude.<$> fileSystemPolicy, + (JSON..=) "FileSystemProtection" Prelude.<$> fileSystemProtection, + (JSON..=) "FileSystemTags" Prelude.<$> fileSystemTags, + (JSON..=) "KmsKeyId" Prelude.<$> kmsKeyId, + (JSON..=) "LifecyclePolicies" Prelude.<$> lifecyclePolicies, + (JSON..=) "PerformanceMode" Prelude.<$> performanceMode, + (JSON..=) "ProvisionedThroughputInMibps" + Prelude.<$> provisionedThroughputInMibps, + (JSON..=) "ReplicationConfiguration" + Prelude.<$> replicationConfiguration, + (JSON..=) "ThroughputMode" Prelude.<$> throughputMode])) +instance Property "AvailabilityZoneName" FileSystem where + type PropertyType "AvailabilityZoneName" FileSystem = Value Prelude.Text + set newValue FileSystem {..} + = FileSystem {availabilityZoneName = Prelude.pure newValue, ..} +instance Property "BackupPolicy" FileSystem where + type PropertyType "BackupPolicy" FileSystem = BackupPolicyProperty + set newValue FileSystem {..} + = FileSystem {backupPolicy = Prelude.pure newValue, ..} +instance Property "BypassPolicyLockoutSafetyCheck" FileSystem where + type PropertyType "BypassPolicyLockoutSafetyCheck" FileSystem = Value Prelude.Bool + set newValue FileSystem {..} + = FileSystem + {bypassPolicyLockoutSafetyCheck = Prelude.pure newValue, ..} +instance Property "Encrypted" FileSystem where + type PropertyType "Encrypted" FileSystem = Value Prelude.Bool + set newValue FileSystem {..} + = FileSystem {encrypted = Prelude.pure newValue, ..} +instance Property "FileSystemPolicy" FileSystem where + type PropertyType "FileSystemPolicy" FileSystem = JSON.Object + set newValue FileSystem {..} + = FileSystem {fileSystemPolicy = Prelude.pure newValue, ..} +instance Property "FileSystemProtection" FileSystem where + type PropertyType "FileSystemProtection" FileSystem = FileSystemProtectionProperty + set newValue FileSystem {..} + = FileSystem {fileSystemProtection = Prelude.pure newValue, ..} +instance Property "FileSystemTags" FileSystem where + type PropertyType "FileSystemTags" FileSystem = [ElasticFileSystemTagProperty] + set newValue FileSystem {..} + = FileSystem {fileSystemTags = Prelude.pure newValue, ..} +instance Property "KmsKeyId" FileSystem where + type PropertyType "KmsKeyId" FileSystem = Value Prelude.Text + set newValue FileSystem {..} + = FileSystem {kmsKeyId = Prelude.pure newValue, ..} +instance Property "LifecyclePolicies" FileSystem where + type PropertyType "LifecyclePolicies" FileSystem = [LifecyclePolicyProperty] + set newValue FileSystem {..} + = FileSystem {lifecyclePolicies = Prelude.pure newValue, ..} +instance Property "PerformanceMode" FileSystem where + type PropertyType "PerformanceMode" FileSystem = Value Prelude.Text + set newValue FileSystem {..} + = FileSystem {performanceMode = Prelude.pure newValue, ..} +instance Property "ProvisionedThroughputInMibps" FileSystem where + type PropertyType "ProvisionedThroughputInMibps" FileSystem = Value Prelude.Double + set newValue FileSystem {..} + = FileSystem + {provisionedThroughputInMibps = Prelude.pure newValue, ..} +instance Property "ReplicationConfiguration" FileSystem where + type PropertyType "ReplicationConfiguration" FileSystem = ReplicationConfigurationProperty + set newValue FileSystem {..} + = FileSystem {replicationConfiguration = Prelude.pure newValue, ..} +instance Property "ThroughputMode" FileSystem where + type PropertyType "ThroughputMode" FileSystem = Value Prelude.Text + set newValue FileSystem {..} + = FileSystem {throughputMode = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/FileSystem/BackupPolicyProperty.hs b/gen/Stratosphere/EFS/FileSystem/BackupPolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/BackupPolicyProperty.hs @@ -0,0 +1,31 @@ +module Stratosphere.EFS.FileSystem.BackupPolicyProperty ( + BackupPolicyProperty(..), mkBackupPolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data BackupPolicyProperty + = -- | See: + BackupPolicyProperty {haddock_workaround_ :: (), + -- | See: + status :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkBackupPolicyProperty :: + Value Prelude.Text -> BackupPolicyProperty +mkBackupPolicyProperty status + = BackupPolicyProperty {haddock_workaround_ = (), status = status} +instance ToResourceProperties BackupPolicyProperty where + toResourceProperties BackupPolicyProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::FileSystem.BackupPolicy", + supportsTags = Prelude.False, + properties = ["Status" JSON..= status]} +instance JSON.ToJSON BackupPolicyProperty where + toJSON BackupPolicyProperty {..} + = JSON.object ["Status" JSON..= status] +instance Property "Status" BackupPolicyProperty where + type PropertyType "Status" BackupPolicyProperty = Value Prelude.Text + set newValue BackupPolicyProperty {..} + = BackupPolicyProperty {status = newValue, ..} diff --git a/gen/Stratosphere/EFS/FileSystem/BackupPolicyProperty.hs-boot b/gen/Stratosphere/EFS/FileSystem/BackupPolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/BackupPolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.FileSystem.BackupPolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data BackupPolicyProperty :: Prelude.Type +instance ToResourceProperties BackupPolicyProperty +instance Prelude.Eq BackupPolicyProperty +instance Prelude.Show BackupPolicyProperty +instance JSON.ToJSON BackupPolicyProperty diff --git a/gen/Stratosphere/EFS/FileSystem/ElasticFileSystemTagProperty.hs b/gen/Stratosphere/EFS/FileSystem/ElasticFileSystemTagProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/ElasticFileSystemTagProperty.hs @@ -0,0 +1,39 @@ +module Stratosphere.EFS.FileSystem.ElasticFileSystemTagProperty ( + ElasticFileSystemTagProperty(..), mkElasticFileSystemTagProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ElasticFileSystemTagProperty + = -- | See: + ElasticFileSystemTagProperty {haddock_workaround_ :: (), + -- | See: + key :: (Value Prelude.Text), + -- | See: + value :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkElasticFileSystemTagProperty :: + Value Prelude.Text + -> Value Prelude.Text -> ElasticFileSystemTagProperty +mkElasticFileSystemTagProperty key value + = ElasticFileSystemTagProperty + {haddock_workaround_ = (), key = key, value = value} +instance ToResourceProperties ElasticFileSystemTagProperty where + toResourceProperties ElasticFileSystemTagProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::FileSystem.ElasticFileSystemTag", + supportsTags = Prelude.False, + properties = ["Key" JSON..= key, "Value" JSON..= value]} +instance JSON.ToJSON ElasticFileSystemTagProperty where + toJSON ElasticFileSystemTagProperty {..} + = JSON.object ["Key" JSON..= key, "Value" JSON..= value] +instance Property "Key" ElasticFileSystemTagProperty where + type PropertyType "Key" ElasticFileSystemTagProperty = Value Prelude.Text + set newValue ElasticFileSystemTagProperty {..} + = ElasticFileSystemTagProperty {key = newValue, ..} +instance Property "Value" ElasticFileSystemTagProperty where + type PropertyType "Value" ElasticFileSystemTagProperty = Value Prelude.Text + set newValue ElasticFileSystemTagProperty {..} + = ElasticFileSystemTagProperty {value = newValue, ..} diff --git a/gen/Stratosphere/EFS/FileSystem/ElasticFileSystemTagProperty.hs-boot b/gen/Stratosphere/EFS/FileSystem/ElasticFileSystemTagProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/ElasticFileSystemTagProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.FileSystem.ElasticFileSystemTagProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ElasticFileSystemTagProperty :: Prelude.Type +instance ToResourceProperties ElasticFileSystemTagProperty +instance Prelude.Eq ElasticFileSystemTagProperty +instance Prelude.Show ElasticFileSystemTagProperty +instance JSON.ToJSON ElasticFileSystemTagProperty diff --git a/gen/Stratosphere/EFS/FileSystem/FileSystemProtectionProperty.hs b/gen/Stratosphere/EFS/FileSystem/FileSystemProtectionProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/FileSystemProtectionProperty.hs @@ -0,0 +1,40 @@ +module Stratosphere.EFS.FileSystem.FileSystemProtectionProperty ( + FileSystemProtectionProperty(..), mkFileSystemProtectionProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data FileSystemProtectionProperty + = -- | See: + FileSystemProtectionProperty {haddock_workaround_ :: (), + -- | See: + replicationOverwriteProtection :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkFileSystemProtectionProperty :: FileSystemProtectionProperty +mkFileSystemProtectionProperty + = FileSystemProtectionProperty + {haddock_workaround_ = (), + replicationOverwriteProtection = Prelude.Nothing} +instance ToResourceProperties FileSystemProtectionProperty where + toResourceProperties FileSystemProtectionProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::FileSystem.FileSystemProtection", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ReplicationOverwriteProtection" + Prelude.<$> replicationOverwriteProtection])} +instance JSON.ToJSON FileSystemProtectionProperty where + toJSON FileSystemProtectionProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "ReplicationOverwriteProtection" + Prelude.<$> replicationOverwriteProtection])) +instance Property "ReplicationOverwriteProtection" FileSystemProtectionProperty where + type PropertyType "ReplicationOverwriteProtection" FileSystemProtectionProperty = Value Prelude.Text + set newValue FileSystemProtectionProperty {..} + = FileSystemProtectionProperty + {replicationOverwriteProtection = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/FileSystem/FileSystemProtectionProperty.hs-boot b/gen/Stratosphere/EFS/FileSystem/FileSystemProtectionProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/FileSystemProtectionProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.FileSystem.FileSystemProtectionProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data FileSystemProtectionProperty :: Prelude.Type +instance ToResourceProperties FileSystemProtectionProperty +instance Prelude.Eq FileSystemProtectionProperty +instance Prelude.Show FileSystemProtectionProperty +instance JSON.ToJSON FileSystemProtectionProperty diff --git a/gen/Stratosphere/EFS/FileSystem/LifecyclePolicyProperty.hs b/gen/Stratosphere/EFS/FileSystem/LifecyclePolicyProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/LifecyclePolicyProperty.hs @@ -0,0 +1,59 @@ +module Stratosphere.EFS.FileSystem.LifecyclePolicyProperty ( + LifecyclePolicyProperty(..), mkLifecyclePolicyProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data LifecyclePolicyProperty + = -- | See: + LifecyclePolicyProperty {haddock_workaround_ :: (), + -- | See: + transitionToArchive :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + transitionToIA :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + transitionToPrimaryStorageClass :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkLifecyclePolicyProperty :: LifecyclePolicyProperty +mkLifecyclePolicyProperty + = LifecyclePolicyProperty + {haddock_workaround_ = (), transitionToArchive = Prelude.Nothing, + transitionToIA = Prelude.Nothing, + transitionToPrimaryStorageClass = Prelude.Nothing} +instance ToResourceProperties LifecyclePolicyProperty where + toResourceProperties LifecyclePolicyProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::FileSystem.LifecyclePolicy", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "TransitionToArchive" Prelude.<$> transitionToArchive, + (JSON..=) "TransitionToIA" Prelude.<$> transitionToIA, + (JSON..=) "TransitionToPrimaryStorageClass" + Prelude.<$> transitionToPrimaryStorageClass])} +instance JSON.ToJSON LifecyclePolicyProperty where + toJSON LifecyclePolicyProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "TransitionToArchive" Prelude.<$> transitionToArchive, + (JSON..=) "TransitionToIA" Prelude.<$> transitionToIA, + (JSON..=) "TransitionToPrimaryStorageClass" + Prelude.<$> transitionToPrimaryStorageClass])) +instance Property "TransitionToArchive" LifecyclePolicyProperty where + type PropertyType "TransitionToArchive" LifecyclePolicyProperty = Value Prelude.Text + set newValue LifecyclePolicyProperty {..} + = LifecyclePolicyProperty + {transitionToArchive = Prelude.pure newValue, ..} +instance Property "TransitionToIA" LifecyclePolicyProperty where + type PropertyType "TransitionToIA" LifecyclePolicyProperty = Value Prelude.Text + set newValue LifecyclePolicyProperty {..} + = LifecyclePolicyProperty + {transitionToIA = Prelude.pure newValue, ..} +instance Property "TransitionToPrimaryStorageClass" LifecyclePolicyProperty where + type PropertyType "TransitionToPrimaryStorageClass" LifecyclePolicyProperty = Value Prelude.Text + set newValue LifecyclePolicyProperty {..} + = LifecyclePolicyProperty + {transitionToPrimaryStorageClass = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/FileSystem/LifecyclePolicyProperty.hs-boot b/gen/Stratosphere/EFS/FileSystem/LifecyclePolicyProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/LifecyclePolicyProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.FileSystem.LifecyclePolicyProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data LifecyclePolicyProperty :: Prelude.Type +instance ToResourceProperties LifecyclePolicyProperty +instance Prelude.Eq LifecyclePolicyProperty +instance Prelude.Show LifecyclePolicyProperty +instance JSON.ToJSON LifecyclePolicyProperty diff --git a/gen/Stratosphere/EFS/FileSystem/ReplicationConfigurationProperty.hs b/gen/Stratosphere/EFS/FileSystem/ReplicationConfigurationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/ReplicationConfigurationProperty.hs @@ -0,0 +1,39 @@ +module Stratosphere.EFS.FileSystem.ReplicationConfigurationProperty ( + module Exports, ReplicationConfigurationProperty(..), + mkReplicationConfigurationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import {-# SOURCE #-} Stratosphere.EFS.FileSystem.ReplicationDestinationProperty as Exports +import Stratosphere.ResourceProperties +data ReplicationConfigurationProperty + = -- | See: + ReplicationConfigurationProperty {haddock_workaround_ :: (), + -- | See: + destinations :: (Prelude.Maybe [ReplicationDestinationProperty])} + deriving stock (Prelude.Eq, Prelude.Show) +mkReplicationConfigurationProperty :: + ReplicationConfigurationProperty +mkReplicationConfigurationProperty + = ReplicationConfigurationProperty + {haddock_workaround_ = (), destinations = Prelude.Nothing} +instance ToResourceProperties ReplicationConfigurationProperty where + toResourceProperties ReplicationConfigurationProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::FileSystem.ReplicationConfiguration", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Destinations" Prelude.<$> destinations])} +instance JSON.ToJSON ReplicationConfigurationProperty where + toJSON ReplicationConfigurationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "Destinations" Prelude.<$> destinations])) +instance Property "Destinations" ReplicationConfigurationProperty where + type PropertyType "Destinations" ReplicationConfigurationProperty = [ReplicationDestinationProperty] + set newValue ReplicationConfigurationProperty {..} + = ReplicationConfigurationProperty + {destinations = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/FileSystem/ReplicationConfigurationProperty.hs-boot b/gen/Stratosphere/EFS/FileSystem/ReplicationConfigurationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/ReplicationConfigurationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.FileSystem.ReplicationConfigurationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ReplicationConfigurationProperty :: Prelude.Type +instance ToResourceProperties ReplicationConfigurationProperty +instance Prelude.Eq ReplicationConfigurationProperty +instance Prelude.Show ReplicationConfigurationProperty +instance JSON.ToJSON ReplicationConfigurationProperty diff --git a/gen/Stratosphere/EFS/FileSystem/ReplicationDestinationProperty.hs b/gen/Stratosphere/EFS/FileSystem/ReplicationDestinationProperty.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/ReplicationDestinationProperty.hs @@ -0,0 +1,95 @@ +module Stratosphere.EFS.FileSystem.ReplicationDestinationProperty ( + ReplicationDestinationProperty(..), + mkReplicationDestinationProperty + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data ReplicationDestinationProperty + = -- | See: + ReplicationDestinationProperty {haddock_workaround_ :: (), + -- | See: + availabilityZoneName :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + fileSystemId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + kmsKeyId :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + region :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + roleArn :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + status :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + statusMessage :: (Prelude.Maybe (Value Prelude.Text))} + deriving stock (Prelude.Eq, Prelude.Show) +mkReplicationDestinationProperty :: ReplicationDestinationProperty +mkReplicationDestinationProperty + = ReplicationDestinationProperty + {haddock_workaround_ = (), availabilityZoneName = Prelude.Nothing, + fileSystemId = Prelude.Nothing, kmsKeyId = Prelude.Nothing, + region = Prelude.Nothing, roleArn = Prelude.Nothing, + status = Prelude.Nothing, statusMessage = Prelude.Nothing} +instance ToResourceProperties ReplicationDestinationProperty where + toResourceProperties ReplicationDestinationProperty {..} + = ResourceProperties + {awsType = "AWS::EFS::FileSystem.ReplicationDestination", + supportsTags = Prelude.False, + properties = Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AvailabilityZoneName" Prelude.<$> availabilityZoneName, + (JSON..=) "FileSystemId" Prelude.<$> fileSystemId, + (JSON..=) "KmsKeyId" Prelude.<$> kmsKeyId, + (JSON..=) "Region" Prelude.<$> region, + (JSON..=) "RoleArn" Prelude.<$> roleArn, + (JSON..=) "Status" Prelude.<$> status, + (JSON..=) "StatusMessage" Prelude.<$> statusMessage])} +instance JSON.ToJSON ReplicationDestinationProperty where + toJSON ReplicationDestinationProperty {..} + = JSON.object + (Prelude.fromList + (Prelude.catMaybes + [(JSON..=) "AvailabilityZoneName" Prelude.<$> availabilityZoneName, + (JSON..=) "FileSystemId" Prelude.<$> fileSystemId, + (JSON..=) "KmsKeyId" Prelude.<$> kmsKeyId, + (JSON..=) "Region" Prelude.<$> region, + (JSON..=) "RoleArn" Prelude.<$> roleArn, + (JSON..=) "Status" Prelude.<$> status, + (JSON..=) "StatusMessage" Prelude.<$> statusMessage])) +instance Property "AvailabilityZoneName" ReplicationDestinationProperty where + type PropertyType "AvailabilityZoneName" ReplicationDestinationProperty = Value Prelude.Text + set newValue ReplicationDestinationProperty {..} + = ReplicationDestinationProperty + {availabilityZoneName = Prelude.pure newValue, ..} +instance Property "FileSystemId" ReplicationDestinationProperty where + type PropertyType "FileSystemId" ReplicationDestinationProperty = Value Prelude.Text + set newValue ReplicationDestinationProperty {..} + = ReplicationDestinationProperty + {fileSystemId = Prelude.pure newValue, ..} +instance Property "KmsKeyId" ReplicationDestinationProperty where + type PropertyType "KmsKeyId" ReplicationDestinationProperty = Value Prelude.Text + set newValue ReplicationDestinationProperty {..} + = ReplicationDestinationProperty + {kmsKeyId = Prelude.pure newValue, ..} +instance Property "Region" ReplicationDestinationProperty where + type PropertyType "Region" ReplicationDestinationProperty = Value Prelude.Text + set newValue ReplicationDestinationProperty {..} + = ReplicationDestinationProperty + {region = Prelude.pure newValue, ..} +instance Property "RoleArn" ReplicationDestinationProperty where + type PropertyType "RoleArn" ReplicationDestinationProperty = Value Prelude.Text + set newValue ReplicationDestinationProperty {..} + = ReplicationDestinationProperty + {roleArn = Prelude.pure newValue, ..} +instance Property "Status" ReplicationDestinationProperty where + type PropertyType "Status" ReplicationDestinationProperty = Value Prelude.Text + set newValue ReplicationDestinationProperty {..} + = ReplicationDestinationProperty + {status = Prelude.pure newValue, ..} +instance Property "StatusMessage" ReplicationDestinationProperty where + type PropertyType "StatusMessage" ReplicationDestinationProperty = Value Prelude.Text + set newValue ReplicationDestinationProperty {..} + = ReplicationDestinationProperty + {statusMessage = Prelude.pure newValue, ..} diff --git a/gen/Stratosphere/EFS/FileSystem/ReplicationDestinationProperty.hs-boot b/gen/Stratosphere/EFS/FileSystem/ReplicationDestinationProperty.hs-boot new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/FileSystem/ReplicationDestinationProperty.hs-boot @@ -0,0 +1,9 @@ +module Stratosphere.EFS.FileSystem.ReplicationDestinationProperty where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.ResourceProperties +data ReplicationDestinationProperty :: Prelude.Type +instance ToResourceProperties ReplicationDestinationProperty +instance Prelude.Eq ReplicationDestinationProperty +instance Prelude.Show ReplicationDestinationProperty +instance JSON.ToJSON ReplicationDestinationProperty diff --git a/gen/Stratosphere/EFS/MountTarget.hs b/gen/Stratosphere/EFS/MountTarget.hs new file mode 100644 --- /dev/null +++ b/gen/Stratosphere/EFS/MountTarget.hs @@ -0,0 +1,82 @@ +module Stratosphere.EFS.MountTarget ( + MountTarget(..), mkMountTarget + ) where +import qualified Data.Aeson as JSON +import qualified Stratosphere.Prelude as Prelude +import Stratosphere.Property +import Stratosphere.ResourceProperties +import Stratosphere.Value +data MountTarget + = -- | See: + MountTarget {haddock_workaround_ :: (), + -- | See: + fileSystemId :: (Value Prelude.Text), + -- | See: + ipAddress :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + ipAddressType :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + ipv6Address :: (Prelude.Maybe (Value Prelude.Text)), + -- | See: + securityGroups :: (ValueList Prelude.Text), + -- | See: + subnetId :: (Value Prelude.Text)} + deriving stock (Prelude.Eq, Prelude.Show) +mkMountTarget :: + Value Prelude.Text + -> ValueList Prelude.Text -> Value Prelude.Text -> MountTarget +mkMountTarget fileSystemId securityGroups subnetId + = MountTarget + {haddock_workaround_ = (), fileSystemId = fileSystemId, + securityGroups = securityGroups, subnetId = subnetId, + ipAddress = Prelude.Nothing, ipAddressType = Prelude.Nothing, + ipv6Address = Prelude.Nothing} +instance ToResourceProperties MountTarget where + toResourceProperties MountTarget {..} + = ResourceProperties + {awsType = "AWS::EFS::MountTarget", supportsTags = Prelude.False, + properties = Prelude.fromList + ((Prelude.<>) + ["FileSystemId" JSON..= fileSystemId, + "SecurityGroups" JSON..= securityGroups, + "SubnetId" JSON..= subnetId] + (Prelude.catMaybes + [(JSON..=) "IpAddress" Prelude.<$> ipAddress, + (JSON..=) "IpAddressType" Prelude.<$> ipAddressType, + (JSON..=) "Ipv6Address" Prelude.<$> ipv6Address]))} +instance JSON.ToJSON MountTarget where + toJSON MountTarget {..} + = JSON.object + (Prelude.fromList + ((Prelude.<>) + ["FileSystemId" JSON..= fileSystemId, + "SecurityGroups" JSON..= securityGroups, + "SubnetId" JSON..= subnetId] + (Prelude.catMaybes + [(JSON..=) "IpAddress" Prelude.<$> ipAddress, + (JSON..=) "IpAddressType" Prelude.<$> ipAddressType, + (JSON..=) "Ipv6Address" Prelude.<$> ipv6Address]))) +instance Property "FileSystemId" MountTarget where + type PropertyType "FileSystemId" MountTarget = Value Prelude.Text + set newValue MountTarget {..} + = MountTarget {fileSystemId = newValue, ..} +instance Property "IpAddress" MountTarget where + type PropertyType "IpAddress" MountTarget = Value Prelude.Text + set newValue MountTarget {..} + = MountTarget {ipAddress = Prelude.pure newValue, ..} +instance Property "IpAddressType" MountTarget where + type PropertyType "IpAddressType" MountTarget = Value Prelude.Text + set newValue MountTarget {..} + = MountTarget {ipAddressType = Prelude.pure newValue, ..} +instance Property "Ipv6Address" MountTarget where + type PropertyType "Ipv6Address" MountTarget = Value Prelude.Text + set newValue MountTarget {..} + = MountTarget {ipv6Address = Prelude.pure newValue, ..} +instance Property "SecurityGroups" MountTarget where + type PropertyType "SecurityGroups" MountTarget = ValueList Prelude.Text + set newValue MountTarget {..} + = MountTarget {securityGroups = newValue, ..} +instance Property "SubnetId" MountTarget where + type PropertyType "SubnetId" MountTarget = Value Prelude.Text + set newValue MountTarget {..} + = MountTarget {subnetId = newValue, ..} diff --git a/stratosphere-efs.cabal b/stratosphere-efs.cabal new file mode 100644 --- /dev/null +++ b/stratosphere-efs.cabal @@ -0,0 +1,85 @@ +cabal-version: 1.12 + +-- This file has been generated from package.yaml by hpack version 0.38.2. +-- +-- see: https://github.com/sol/hpack + +name: stratosphere-efs +version: 1.0.0 +synopsis: Stratosphere integration for AWS EFS. +description: Integration into stratosphere to generate resources and properties for AWS EFS +category: AWS, Cloud, EFS +stability: experimental +homepage: https://github.com/mbj/stratosphere#readme +bug-reports: https://github.com/mbj/stratosphere/issues +maintainer: Markus Schirp +license: MIT +license-file: LICENSE.md +build-type: Simple + +source-repository head + type: git + location: https://github.com/mbj/stratosphere + +flag development + description: Run GHC with development flags + manual: True + default: False + +library + exposed-modules: + Stratosphere.EFS.AccessPoint + Stratosphere.EFS.AccessPoint.AccessPointTagProperty + Stratosphere.EFS.AccessPoint.CreationInfoProperty + Stratosphere.EFS.AccessPoint.PosixUserProperty + Stratosphere.EFS.AccessPoint.RootDirectoryProperty + Stratosphere.EFS.FileSystem + Stratosphere.EFS.FileSystem.BackupPolicyProperty + Stratosphere.EFS.FileSystem.ElasticFileSystemTagProperty + Stratosphere.EFS.FileSystem.FileSystemProtectionProperty + Stratosphere.EFS.FileSystem.LifecyclePolicyProperty + Stratosphere.EFS.FileSystem.ReplicationConfigurationProperty + Stratosphere.EFS.FileSystem.ReplicationDestinationProperty + Stratosphere.EFS.MountTarget + other-modules: + Paths_stratosphere_efs + hs-source-dirs: + gen + default-extensions: + DataKinds + DeriveGeneric + DerivingStrategies + DerivingVia + DuplicateRecordFields + FlexibleContexts + FlexibleInstances + GADTs + GeneralizedNewtypeDeriving + InstanceSigs + LambdaCase + MultiParamTypeClasses + NoFieldSelectors + NoImplicitPrelude + NumericUnderscores + OverloadedLists + OverloadedRecordDot + OverloadedStrings + PolyKinds + RecordWildCards + ScopedTypeVariables + StandaloneDeriving + Strict + TemplateHaskell + TupleSections + TypeApplications + TypeFamilies + ghc-options: -Wall -Wcompat -Widentities -Wimplicit-prelude -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-local-signatures -Wmissing-signatures -Wmonomorphism-restriction -Wredundant-constraints -fhide-source-paths -funbox-strict-fields -optP-Wno-nonportable-include-path -Wno-unused-imports + build-depends: + aeson ==2.* + , base >=4.8 && <4.22 + , stratosphere ==1.0.0 + default-language: Haskell2010 + if flag(development) + ghc-options: -Werror + else + ghc-options: -Wwarn